tictacsync 0.5a0__py3-none-any.whl → 0.6a0__py3-none-any.whl

tictacsync/yaltc.py

@@ -5,7 +5,7 @@ import lmfit, tempfile
 # from skimage.morphology import closing, square
 from numpy import arcsin, sin, pi
 from matplotlib.lines import Line2D
-import math, re, os, sys
+import math, re, os, sys, itertools
 import sox
 from subprocess import Popen, PIPE
 from pathlib import Path
@@ -18,6 +18,8 @@ from datetime import datetime, timezone, timedelta
 from collections import deque
 from loguru import logger
 from sklearn.mixture import GaussianMixture
+from skimage.morphology import closing, erosion, remove_small_objects
+from skimage.measure import regionprops, label
 import ffmpeg, shutil
 from rich import print
 from rich.console import Console
@@ -28,6 +30,8 @@ try:
 except:
     import device_scanner
 
+TEENSY_MAX_LAG = 128/44100 # sec, duration of a default length audio block
+
 
 CACHING = True
 DEL_TEMP = False
@@ -41,6 +45,13 @@ WORDWIDTHFACTOR = 2
 
 OVER_NOISE_SYNC_DETECT_LEVEL = 2
 
+################## pasted from FSKfreqCalculator.py output:
+F1 = 630.00 # Hertz
+F2 = 1190.00 # Hz , both from FSKfreqCalculator output
+SYMBOL_LENGTH = 14.286 # ms, from FSKfreqCalculator.py
+N_SYMBOLS = 35 # including sync pulse
+##################
+
 MINIMUM_LENGTH = 4 # sec
 TRIAL_TIMES = [ # in seconds
             (0.5, -2),
@@ -52,18 +63,12 @@ TRIAL_TIMES = [ # in seconds
             (3.5, -2),
             (3.5, -3.5),
             ]
-SOUND_EXTRACT_LENGTH = 1.56 # second
+SOUND_EXTRACT_LENGTH = (10*SYMBOL_LENGTH*1e-3 + 1) # second
 SYMBOL_LENGTH_TOLERANCE = 0.07 # relative
 FSK_TOLERANCE = 60 # Hz
 SAMD21_LATENCY = 63 # microseconds, for DAC conversion
 YEAR_ZERO = 2021
 
-################## pasted from FSKfreqCalculator.py output:
-F1 = 630.00 # Hertz
-F2 = 1190.00 # Hz , both from FSKfreqCalculator output
-SYMBOL_LENGTH = 14.286 # ms, from FSKfreqCalculator.py
-N_SYMBOLS_SAMD21 = 35 # including sync pulse
-##################
 
 BPF_LOW_FRQ, BPF_HIGH_FRQ = (0.5*F1, 2*F2)
 
@@ -81,6 +86,12 @@ def _pathname(tempfile_or_path):
             tempfile_or_path,
             type(tempfile_or_path)))
 
+# for skimage.measure.regionprops
+def _width(region):
+    _,x1,_,x2 = region.bbox
+    return x2-x1
+
+
 def to_precision(x,p):
     """
     returns a string representation of x formatted with a precision of p
@@ -154,8 +165,8 @@ class Decoder:
         rec : Recording
             recording on which the decoder is working
     
-        SN_ratio : float
-            signal over noise ratio in dB.
+        effective_word_duration : float
+            duration of a word, influenced by ucontroller clock
 
         pulse_detection_level : float
             level used to detect sync pulse
@@ -176,7 +187,7 @@ class Decoder:
 
     """
 
-    def __init__(self, aRec):
+    def __init__(self, aRec, do_plots):
         """
         Initialises Decoder
 
@@ -186,587 +197,307 @@ class Decoder:
 
         """
         self.rec = aRec
+        self.do_plots = do_plots
         self.clear_decoder()
 
+
     def clear_decoder(self):
         self.sound_data_extract = None
-        self.cached_convolution_fit = {'sound_extract_position': None}
         self.pulse_detection_level = None
-        self.silent_zone_indices = None
         self.detected_pulse_position = None
-        self.estimated_pulse_position = None
-
-    def set_sound_extract_and_sr(self, extract, s_r, where):
-        self.sound_extract = extract
-        self.samplerate = s_r
-        self.sound_extract_position = where
-        self.cached_convolution_fit = {'sound_extract_position': None}
-        logger.debug('sound_extract set, samplerate %i location %i'%(s_r, where))
-   
-
-        # there's always at least one complete 0.5 silence interval in a 1.5 second signal
-
-    def _get_envelope(self):
-        """
-        Compute self.sound_extract envelope, filtering its hilbert transform.
-        Uses scipy.signal.hilbert() and scipy.signal.savgol_filter();
-        window_length and polyorder savgol_filter() parameters values 
-        have been found by hit and miss on audio data.
-
-        maybe:
-        Values are roughly normalized: between 0 and approximately 1.0
-
-        Returns
-        -------
-        numpy.ndarray the same length of self.recording.sound_extract
-
-        """
-        WINDOW_LENGTH, POLYORDER = (15, 3) # parameters found by experiment, hit and miss
-        absolute_of_hilbert = np.abs(scipy.signal.hilbert(self.sound_extract))
-        envelope = scipy.signal.savgol_filter(absolute_of_hilbert,
-                                              WINDOW_LENGTH, POLYORDER)
-        logger.debug('self.sound_extract envelope length %i samples'%len(envelope))
-        return envelope
-
-    def _get_signal_level(self):
-        abs_signal = abs(self.sound_extract)
-        return 2 * abs_signal.mean() # since 50% duty cycle
-
-    def _get_approx_pulse_position(self):
-        """
-        Returns the estimated pulse position using the detected silent
-        zone . The position is in samples number
-        relative to extract beginning
-        """
-        # if self.detected_pulse_position:
-        #     logger.debug('returning detected value')
-        #     return self.detected_pulse_position
-        if self.estimated_pulse_position:
-            logger.debug('returning cached estimated value')
-            return self.estimated_pulse_position ###############################
-        _, silence_center_x = self._fit_triangular_signal_to_convoluted_env()
-        # symbol_width_samples = 1e-3*SYMBOL_LENGTH
-        self.estimated_pulse_position = silence_center_x + int(0.5*(
-            0.5 - 1e-3*SYMBOL_LENGTH)*self.samplerate)
-        logger.debug('returning estimated value from silence mid position')
-        return self.estimated_pulse_position
-
-    def _get_pulse_position(self):
-        # relative to extract beginning
-        if self.detected_pulse_position:
-            logger.debug('returning detected value')
-            return self.detected_pulse_position
-        return None
-
-    def _get_pulse_detection_level(self):
-        # return level at which the sync pulse will be detected
-        if self.pulse_detection_level is None:
-            silence_floor = self._get_silence_floor()
-            # lower_BFSK_level = silence_floor
-            # pulse_position = self._get_pulse_position()
-            lower_BFSK_level = self._get_minimal_bfsk()
-            value = math.sqrt(silence_floor * lower_BFSK_level)
-            # value = OVER_NOISE_SYNC_DETECT_LEVEL * silence_floor
-            logger.debug('setting pulse_detection_level to %f'%value)
-            self.pulse_detection_level = value
-            return value
-        else:
-            return self.pulse_detection_level
-
-    def _get_square_convolution(self):
-        """
-        Compute self.sound_extract envelope convolution with a square signal of
-        0.5 second (+ SYMBOL_LENGTH) width, using numpy.convolve().
-        Values are roughly normalized: between 0 and approximately 1.0
-
-
-        Returns:
-    
-         #1 the normalized convolution, a numpy.ndarray shorter than 
-             self.sound_extract, see numpy.convolve(..., mode='valid')
-
-         #2 a list of int, samples indexes where the convolution is computed
-
-        """
-        sqr_window_width = int((0.5 + SYMBOL_LENGTH/1e3)*self.samplerate) # in samples
-        sqr_signal = np.ones(sqr_window_width,dtype=int)
-        envelope = self._get_envelope()
-        mean = envelope.mean()
-        if mean: # in case of zero padding (? dont remember why)
-            factor = 0.5/mean # since 50% duty cycle
-        else:
-            factor = 1
-        normalized_envelope = factor*envelope
-        convol = np.convolve(normalized_envelope, sqr_signal,
-                             mode='valid')/sqr_window_width
-        start = int(sqr_window_width/2)
-
-        x = range(start, len(convol) + start)
-        return [*x], convol
-
-    def _get_word_envelope(self):
-        """
-        Chop the signal envelope keeping the word region and smooth it over the
-        longest BFSK period
-        """
-        SR = self.samplerate
-        envelope = self._get_envelope()
-        pulse_position = self._get_approx_pulse_position()
-        samples_to_end = len(self.sound_extract) - pulse_position
-        is_too_near_the_end = samples_to_end/SR < 0.5
-        logger.debug('pulse_position is_too_near_the_end %s'%
-            is_too_near_the_end)
-        if is_too_near_the_end:
-            pulse_position -= SR # one second sooner
-        symbol_width_samples = 1e-3*SYMBOL_LENGTH*SR
-        word_start = int(pulse_position + 3*symbol_width_samples)
-        word_end = int(pulse_position + 0.5*SR)
-        word_end -= int(2*symbol_width_samples) # slide to the left a little
-        logger.debug('word start, end: %i %i (in extract)'%(
-            word_start, word_end))
-        logger.debug('word start, end: %i %i (in file)'%(
-            word_start + self.sound_extract_position,
-            word_end + self.sound_extract_position))
-        w_envelope = envelope[word_start : word_end]
-        word_envelope_truncated = word_end-word_start != len(w_envelope)
-        logger.debug('w_envelope is sliced out of bounds: %s'%(
-            str(word_envelope_truncated)))
-        logger.debug('word envelope length %i samples %f secs'%(
-            len(w_envelope), len(w_envelope)/SR))
-        max_period = int(self.samplerate*max(1/F1,1/F2))
-        logger.debug('max BFSK period %i in samples'%max_period)
-        period_window = np.ones(max_period,dtype=int)/max_period
-        # smooth over longest BFSK period
-        return np.convolve(w_envelope, period_window, mode='same')
-
-    def _get_minimal_bfsk(self):
-        """
-        because of non-flat frequency response, bfsk bits dont have the same
-        amplitude. This returns the least of both by detecting a bimodal
-        gaussian distribution
-
-        """
-        # w_envelope = self._get_word_envelope()
-        # word_start = int(min_position + shift + 0.3*self.samplerate)
-        # word = w_envelope[word_start :  int(word_start + 0.4*self.samplerate)]
-        word = self._get_word_envelope()
-        # plt.plot(word)
-        # plt.show()
-        n = len(word)
-        word = word.reshape(n, 1)
-        gm = GaussianMixture(n_components=2, random_state=0).fit(word)
-        bfsk_minimal_amplitude = min(gm.means_)
-        logger.debug('bfsk_minimal_amplitude %f'%bfsk_minimal_amplitude)
-        return bfsk_minimal_amplitude
-
-    def _fit_triangular_signal_to_convoluted_env(self):
+        
+    def set_sound_extract_and_sr(self, sound_extract, samplerate, sound_extract_position):
         """
-        Try to fit a triangular signal to the envelope convoluted with a square
-        signal to evaluate if audio is composed of 0.5 sec signal and 0.5 s 
-        silence. If so, the convolution is a triangular fct and a
-        Levenberg–Marquardt fit is used to detect this occurence (lmfit).
-        Results are cached in self.cached_convolution_fit alongside
-        self.sound_extract_position for hit/miss checks.
-
+        Sets:
+            self.sound_extract -- mono data of short duration
+            self.samplerate -- in Hz
+            self.sound_extract_position -- position in the whole file
 
-        Returns
-        -------
-        float
-            chi_sqr from lmfit.minimize(), indicative of fit quality
-        int
-            position of triangular minimum (base of the v shape), this
-            corresponds to the center of silent zone.
+        Computes and sets:
+            self.pulse_detection_level
+            self.sound_extract_one_bit
+            self.words_props (contains the sync pulse too)
 
+        Returns nothing
         """
-        cached_value = self.cached_convolution_fit['sound_extract_position']
-        logger.debug('cache hit? asked:%s cached: %s'%(
-                        self.sound_extract_position,
-                        cached_value))
-        logger.debug('(sound_extract_position values)')
-        if (CACHING and
-                    # cache_is_clean and
-                    cached_value and 
-                    math.isclose(
-                        self.sound_extract_position,
-                        cached_value,
-                        abs_tol=0.1)):
-            logger.debug('yes, fit values cached:')
-            v1 = self.cached_convolution_fit['chi_square']
-            v2 = self.cached_convolution_fit['minimum position']
-            v2_file = v2 + self.sound_extract_position
-            logger.debug('cached chi_sq: %s minimum position in file: %s'%
-                (v1, v2_file))
-            return (v1, v2) ####################################################
-                # cached!
-        x_shifted, convolution = self._get_square_convolution()
-        # see numpy.convolve(..., mode='valid')
-        x = np.arange(len(convolution))
-        trig_params = lmfit.Parameters()
-        trig_params.add(
-            'A', value=1, min=0, max=2
-            )
-        period0 = 2*self.samplerate
-        trig_params.add(
-            'period', value=period0, min=0.9*period0,
-            max=1.1*period0
-            )
-        trig_params.add(
-            'min_position', value=len(convolution)/2
-            ) # at center
-        def trig_wave(pars, x, signal_data=None):
-            # looking for phase sx with a sin of 1 sec period and 0<y<1.0
-            A = pars['A']
-            p = pars['period']
-            mp = pars['min_position']
-            model = 2*A*arcsin(abs(sin((x - mp)*2*pi/p)))/pi
-            if signal_data is None:
-                return model ###################################################
-            return model - signal_data
-        fit_trig = lmfit.minimize(
-                            trig_wave, trig_params,
-                            args=(x,), kws={'signal_data': convolution}
-                            )
-        chi_square = fit_trig.chisqr
-        shift = x_shifted[0] # convolution is shorter than sound envelope
-        min_position = int(fit_trig.params['min_position'].value) + shift
-        logger.debug('chi_square %.1f minimum convolution position %i in file'%
-                     (chi_square, min_position + self.sound_extract_position))
-        self.cached_convolution_fit['sound_extract_position'] = \
-                                                self.sound_extract_position
-        self.cached_convolution_fit['chi_square'] = chi_square
-        self.cached_convolution_fit['minimum position'] = min_position
-
-        return chi_square, min_position + shift
+        logger.debug('sound_extract: %s, samplerate: %s Hz, sound_extract_position %s'%(
+                sound_extract, samplerate, sound_extract_position))
+        if len(sound_extract) == 0:
+            logger.error('sound extract is empty, is sound track duration OK?')
+            raise Exception('sound extract is empty, is sound track duration OK?')
+        self.sound_extract_position = sound_extract_position
+        self.samplerate = samplerate
+        self.sound_extract = sound_extract
+        self.pulse_detection_level = np.std(sound_extract)/4
+        logger.debug('pulse_detection_level %f'%self.pulse_detection_level)
+        bits = np.abs(sound_extract)>self.pulse_detection_level
+        N_ones = round(1.5*SYMBOL_LENGTH*1e-3*samplerate) # so it includes sync pulse
+        self.sound_extract_one_bit = closing(bits, np.ones(N_ones))
+        if self.do_plots:
+            self._plot_extract()
+        logger.debug('sound_extract_one_bit len %i'%len(self.sound_extract_one_bit))
+        self.words_props = regionprops(label(np.array(2*[self.sound_extract_one_bit]))) # new
 
     def extract_seems_TicTacCode(self):
-        """margin
-        evaluate if sound data is half signal, half silence
-        no test is done on frequency components nor BFSK modulation.
-
-        Returns
-        -------
-        True if sound seems TicTacCode
-
-        """
-        chi_square, _ = self._fit_triangular_signal_to_convoluted_env()
-        seems_TicTacCode = chi_square < 200 # good fit so, yes
-        logger.debug('seems TicTacCode: %s'%seems_TicTacCode)
-        return seems_TicTacCode
+        """        
+        Determines if signal in sound_extract seems to be TTC.
 
-    def _get_silent_zone_indices(self):
-        """
-        Returns silent zone boundary positions relative to the start
-        of self.sound_extract.
+        Uses the conditions below:
 
-        Returns
-        -------
-        left_window_boundary : int
-            left indice.
-        right_window_boundary : int
-            right indice.
+            Extract duration is 1.143 s.
+            In self.word_props (list of morphology.regionprops):
+                if one region, duration should be in [0.499 0.512] sec
+                if two regions, total duration should be in [0.50 0.655]
 
+        Returns True if self.sound_data_extract seems TicTacCode
         """
-        if self.silent_zone_indices:
-            return self.silent_zone_indices ####################################
-        _, silence_center_position = \
-            self._fit_triangular_signal_to_convoluted_env()
-        srate = self.samplerate
-        half_window = int(SAFE_SILENCE_WINDOW_WIDTH * 1e-3 * srate/2)
-        left_window_boundary = silence_center_position - half_window
-        right_window_boundary = silence_center_position + half_window
-        # margin = 0.75 * srate
-        values = np.array([left_window_boundary, right_window_boundary,
-                    silence_center_position])
-        values += self.sound_extract_position # samples pos in file
-        logger.debug('silent zone, left: %i, right %i, center %i'%tuple(values))
-        self.silent_zone_indices = (left_window_boundary, right_window_boundary)
-        return self.silent_zone_indices
- 
-    def _get_silence_floor(self):
-        # analyses the 0.5 silence zone
-        start_silent_zone, end_silent_zone = self._get_silent_zone_indices()
-        signal = self.sound_extract
-        silent_signal = signal[start_silent_zone:end_silent_zone]
-        max_value = 1.001*np.abs(silent_signal).max() # a little headroom
-        max_value = 0 # should toggle this with a CLI option
-        five_sigmas = 5 * silent_signal.std()
-        return max(max_value, five_sigmas) # if guassian, five sigmas will do it
-
-    def make_silence_analysis_plot(self, title=None, filename=None):
-        # save figure in filename if set, otherwise
-        # start an interactive plot, title is for matplotlib
-        pulse_pos_in_file = self._get_approx_pulse_position()
-        pulse_pos_in_file += self.sound_extract_position
-        pulse_position_sec = pulse_pos_in_file/self.samplerate
-        duration_in_sec = self.rec.get_duration()
-        if pulse_position_sec > duration_in_sec/2:
-            pulse_position_sec -= duration_in_sec
-        title = 'Silence analysis around %.2f s'%(pulse_position_sec)
-        logger.debug('make_silence_analysis_plot(title=%s, filename=%s)'%(
-                                title, filename))
-        start_silent_zone, end_silent_zone = self._get_silent_zone_indices()
-        signal = self.sound_extract
-        x_signal = range(len(signal))
-        x_convolution, convolution = self._get_square_convolution()
-        scaled_convo = self._get_signal_level()*convolution
-        # since 0 < convolution < 1
-        trig_level = self._get_pulse_detection_level()
-        sound_extract_position = self.sound_extract_position
-        def x2f(nx):
-            return nx + sound_extract_position
-        def f2x(nf):
-            return nf - sound_extract_position
+        failing_comment = '' # used as a flag
+        props = self.words_props
+        if len(props) not in [1,2]:
+            failing_comment = 'len(props) not in [1,2]: %i'%len(props)
+        if len(props) == 1:
+            w = _width(props[0])/self.samplerate
+            # self.effective_word_duration = w
+            # logger.debug('effective_word_duration %f (one region)'%w)
+            if not 0.499 < w < 0.512: # TODO: move as TOP OF FILE PARAMS
+                failing_comment = '_width %f not in [0.499 0.512]'%w
+        else: # 2 regions
+            widths = [_width(p)/self.samplerate for p in props] # in sec
+            total_w = sum(widths)
+            # extra_window_duration = SOUND_EXTRACT_LENGTH - 1
+            # eff_w = total_w - extra_window_duration
+            # logger.debug('effective_word_duration %f (two regions)'%eff_w)
+            if not 0.5 < total_w < 0.655:
+                failing_comment = 'two regions duration %f not in [0.50 0.655]\n%s'%(total_w, widths)
+                # fig, ax = plt.subplots()
+                # p(ax, sound_extract_one_bit)
+        logger.debug('failing_comment: %s'%(
+            'none' if failing_comment=='' else failing_comment))
+        return failing_comment == '' # no comment = extract seems TicTacCode
+
+    def _plot_extract(self):
         fig, ax = plt.subplots()
-        plt.title(title)
-        secax = ax.secondary_xaxis('top', functions=(x2f, f2x))
-        # secax.set_xlabel('position in file')
-        # ax.set_xlabel('position in extract')
-        yt = ax.get_yaxis_transform()
+        ax.plot(self.sound_extract, marker='o', markersize='1',
+            linewidth=1.5,alpha=0.3, color='blue' )
+        ax.plot(self.sound_extract_one_bit*np.max(np.abs(self.sound_extract)), 
+            marker='o', markersize='1',
+            linewidth=1.5,alpha=0.3,color='red')
         xt = ax.get_xaxis_transform()
-        _, silence_center_x = self._fit_triangular_signal_to_convoluted_env()
-        # symbol_width_samples = 1e-3*SYMBOL_LENGTH
-        # pulse_relative_pos = int(0.5*(0.5 - 1e-3*SYMBOL_LENGTH)*self.samplerate)
-        approx_pulse_x = self._get_approx_pulse_position()
-        ax.vlines(
-            silence_center_x, 0.4, 0.6, 
-            transform=xt, linewidth=1, colors='black'
-            )
-        ax.vlines(
-            approx_pulse_x, 0.1, 0.9, 
-            transform=xt, linewidth=1, colors='yellow'
-            )
-        bfsk_min = self._get_minimal_bfsk()
-        ax.hlines(
-            bfsk_min, 0, 1, 
-            transform=yt, linewidth=1, colors='red'
-            )
-        ax.hlines(
-            trig_level, 0, 1, 
-            transform=yt, linewidth=1, colors='blue'
-            )
-        ax.hlines(
-            -trig_level, 0, 1, 
-            transform=yt, linewidth=1, colors='blue'
-            )
-        ax.hlines(
-            0, 0, 1, 
-            transform=yt, linewidth=0.5, colors='black'
-            )
-        # plt.title(title)
+        yt = ax.get_yaxis_transform()
+        ax.hlines(self.pulse_detection_level, 0, 1,
+            transform=yt, alpha=0.3,
+        linewidth=2, colors='green')
         custom_lines = [
-            Line2D([0], [0], color='black', lw=2),
             Line2D([0], [0], color='green', lw=2),
             Line2D([0], [0], color='blue', lw=2),
             Line2D([0], [0], color='red', lw=2),
-            Line2D([0], [0], color='yellow', lw=2),
             ]
         ax.legend(
             custom_lines,
-            'sqr convolution,silence zone,pulse level,lower FSK ampl., approx puls.'.split(','),
+            'detection level, signal, detected region'.split(','),
             loc='lower right')
-        ax.plot(
-            x_signal, signal,
-            marker='o', markersize='1',
-            linewidth=0.3, color='purple', alpha=0.3)
-        ax.axvspan(
-            start_silent_zone, end_silent_zone,
-            alpha=0.1, color='green')
-        ax.plot(
-            x_convolution, scaled_convo,
-            marker='.', markersize='0.2',
-            linestyle='None', color='black', alpha=1)
-            # linewidth=0.3, linestyle='None', color='black', alpha=0.3)
-        # ax.set_xlabel('Decoder.sound_extract samples')
-        if filename == None:
-            plt.show()
-        else:
-            logger.debug('saving silence_analysis_plot to %s'%filename)
-            plt.savefig(
-                filename,
-                format="png")
-            plt.close()
-
-    def _detect_sync_pulse_position(self):
-        """
-        Determines noise level during silence period and use it to detect the
-        sync pulse position. Computes SN_ratio and stores it. Start searching
-        around end of silent zone. Adjustment are made so a complete 0.5
-        second signal is at the right of the starting search position so a
-        complete 0.5 s word is available for decoding.
+        ax.set_title('Finding word and sync pulse')
+        plt.show()
 
-        Returns the pulse position relative to the extract beginning.
-
-        Sets self.detected_pulse_position to the returned value.
+    def get_time_in_sound_extract(self):
+        """        
+        Tries to decode time present in self.sound_extract, if successfull
+        return a time dict, eg:{'version': 0, 'seconds':
+        44, 'minutes': 57, 'hours': 19,
+        'day': 1, 'month': 3, 'year offset': 1, 
+        'pulse at': 670451.2217 } otherwise return None
         """
-        pulse_detection_level = self._get_pulse_detection_level()
-        abs_signal = abs(self.sound_extract)
-        mean_during_word = 2*abs_signal.mean()
-        self.SN_ratio = 20*math.log10(mean_during_word/pulse_detection_level)
-        logger.debug('SN ratio: %f dB'%(self.SN_ratio))
-        search_pulse_start_point = self._get_approx_pulse_position()
-        search_pulse_start_point -= 3*SYMBOL_LENGTH*1e-3*self.samplerate
-        search_pulse_start_point = int(search_pulse_start_point)
-        # search_pulse_start_point = end_silent_zone
-        logger.debug('_get_pulse_position %i as starting point'%search_pulse_start_point)
-        distance_to_end = len(self.sound_extract) - search_pulse_start_point
-        time_to_end = distance_to_end/self.samplerate
-        logger.debug('time_to_end after search_pulse_start_point %f sec'%
-                                        time_to_end)
-        if time_to_end < 0.5 + SYMBOL_LENGTH*1e-3: # sec
-            logger.debug('search_pulse_start_point too near the end')
-            # go back one second
-            search_pulse_start_point -= self.samplerate
-            logger.debug('new starting point %i'%search_pulse_start_point)
+        pulse_detected = self._detect_sync_pulse_position()
+        if not pulse_detected:
+            return None
+        symbols_data = self._get_symbols_data()
+        frequencies = [self._get_main_frequency(data_slice)
+                            for data_slice in symbols_data ]
+        logger.debug('found frequencies %s'%frequencies)
+        def _get_bit_from_freq(freq):
+            mid_FSK = 0.5*(F1 + F2)
+            return '1' if freq > mid_FSK else '0'
+        bits = [_get_bit_from_freq(f) for f in frequencies]
+        bits_string = ''.join(bits)
+        logger.debug('giving bits:  LSB %s MSB'%bits_string)
+
+        def _values_from_bits(bits):
+            word_payload_bits_positions = {
+                # start, finish (excluded)
+                'version':(0,3), # 3 bits
+                'seconds':(3,9), # 6 bits
+                'minutes':(9,15),
+                'hours':(15,20),
+                'day':(20,25),
+                'month':(25,29),
+                'year offset':(29,34),
+                }
+            binary_words = { key : bits[slice(*value)]
+                    for key, value 
+                    in word_payload_bits_positions.items()
+                    }
+            int_values = { key : int(''.join(reversed(val)),2)
+                    for key, val in binary_words.items()
+                    }
+            return int_values
+        time_values = _values_from_bits(bits_string)
+        logger.debug(' decoded time %s'%time_values)
+        sync_pos_in_file = self.detected_pulse_position + \
+                    self.sound_extract_position
+        time_values['pulse at'] = sync_pos_in_file
+        return time_values
+    
+    def _detect_sync_pulse_position(self):
+        # sets self.detected_pulse_position, relative to sound_extract
+        #
+        regions = self.words_props # contains the sync pulse too
+        # len(self.words_props) should be 1 or 2 for vallid TTC
+        logger.debug('len() of words_props: %i'%len(self.words_props))
+        whole_region = [p for p in regions if 0.499 < _width(p)/self.samplerate < 0.512]
+        logger.debug('region widths %s'%[_width(p)/self.samplerate for p in regions])
+        logger.debug('number of whole_region %i'%len(whole_region))
+        if len(regions) == 1 and len(whole_region) != 1:
+            # oops
+            logger.debug('len(regions) == 1 and len(whole_region) != 1, failed')
+            return False #######################################################
+        if len(whole_region) > 1:
+            print('error in _detect_sync_pulse_position: len(whole_region) > 1 ')
+            return False #######################################################
+        if len(whole_region) == 1:
+            # sync pulse at the begining of this one
+            _, spike, _, _ = whole_region[0].bbox
         else:
-            logger.debug('ok, ample room for 0.5 s word')
-        search_pulse_start_point = max(search_pulse_start_point, 0)
-        logger.debug('search_pulse_start_point: %i in extract'%
-                search_pulse_start_point)
-        abs_signal_after_silence = abs_signal[search_pulse_start_point:]
-        # here the real searching with numpy.argmax()
-        first_point = \
-                    np.argmax(abs_signal_after_silence > pulse_detection_level)
-        first_point += search_pulse_start_point
-        logger.debug('found sync pulse at %i in extract'%first_point)
-        logger.debug('found sync pulse at %i in file'%(first_point
-                + self.sound_extract_position))
-        distance_to_end = len(self.sound_extract) - first_point
-        time_to_end = distance_to_end/self.samplerate
-        logger.debug('time_to_end after detected pulse %f sec'%
-                                        time_to_end)
-        if time_to_end < 0.5 + SYMBOL_LENGTH*1e-3: # sec
-            logger.debug('detected_pulse_position too near the end')
-            logger.debug('back one second')
-            first_point -= self.samplerate
-            logger.debug('new sync pulse at %i in extract'%first_point)
-            logger.debug('new sync pulse at %i in file'%first_point)
+            # whole_region is [] (all fractionnal) and
+            # sync pulse at the begining of the 2nd region
+            _, spike, _, _ = regions[1].bbox
+            # but check there is still enough place for ten bits: 
+            # 6 for secs + 3 for revision + blanck after sync
+            minimum_samples = int(self.samplerate*10*SYMBOL_LENGTH*1e-3)
+            whats_left = len(self.sound_extract) - spike
+            if whats_left < minimum_samples:
+                spike -= self.samplerate
+                # else: stay there, will decode seconds in whats_left
+        half_symbol_width = int(0.5*1e-3*SYMBOL_LENGTH*self.samplerate) # samples
+        left, right = (spike - half_symbol_width, spike+half_symbol_width)
+        spike_data = self.sound_extract[left:right]
+        biggest_positive = np.max(spike_data)
+        biggest_negative = np.min(spike_data)
+        if abs(biggest_negative) > biggest_positive:
+            # flip
+            spike_data = -1 * spike_data
+        def fit_line_until_negative():
+            import numpy as np
+            start = np.argmax(spike_data)
+            xs = [start]
+            ys = [spike_data[start]]
+            i = 1
+            while spike_data[start - i] > 0 and start - i >= 0:
+                xs.append(start - i)
+                ys.append(spike_data[start - i])
+                i += 1
+            # ax.scatter(xs, ys)
+            import numpy as np
+            coeff = np.polyfit(xs, ys, 1)
+            m, b = coeff
+            zero = int(-b/m)
+            # check if data is from USB audio and tweak
+            y_fit = np.poly1d(coeff)(xs)
+            err = abs(np.sum(np.abs(y_fit-ys))/np.mean(ys))
+            logger.debug('fit error for line in ramp: %f'%err)
+            if err < 0.01: #good fit so not analog
+                zero += 1
+            return zero
+        sync_sample = fit_line_until_negative() + left
+        logger.debug('sync pulse found at %i in extract, %i in file'%(
+                        sync_sample, sync_sample + self.sound_extract_position))
+        self.detected_pulse_position = sync_sample
+        return True
+    
+    def _get_symbols_data(self):
+        # part of extract AFTER sync pulse
+        whats_left = len(self.sound_extract) - self.detected_pulse_position # in samples
+        whats_left /= self.samplerate # in sec
+        whole_word_is_in_extr = whats_left > 0.512 
+        if whole_word_is_in_extr:
+            # one region
+            logger.debug('word is in one sole region')
+            length_needed = round(0.5*self.samplerate)
+            length_needed += round(self.samplerate*SYMBOL_LENGTH*1e-3)
+            whole_word = self.sound_extract[self.detected_pulse_position:
+                                           self.detected_pulse_position + length_needed]
         else:
-            logger.debug('ok, ample room for 0.5 s word after detected pulse')            
-        self.detected_pulse_position = first_point
-        return first_point
-
-    def _get_word_width_parameters(self):
-        """
-        Returns the parameters used to find and demodulate 2FSK word:
-        presumed_symbol_length
-        word_width_threshold
-        search_end_position
-        """
-        abs_signal = abs(self.sound_extract)
-        pulse_position = self._get_pulse_position()
-        bfsk_min = self._get_minimal_bfsk()
-        params = {'word_width_threshold': 0.8*bfsk_min}
-        sr = self.samplerate
-        presumed_symbol_length = SYMBOL_LENGTH*1e-3*sr
-        # in ms, now in samples
-        presumed_word_width = presumed_symbol_length * N_SYMBOLS_SAMD21
-        # word includes sync pulse
-        params['search_end_position'] = \
-                    int(presumed_symbol_length + pulse_position + \
-                    presumed_word_width) + 1700 # samples for headroom 
-        params['presumed_symbol_length'] = presumed_symbol_length
-        return params
-
-    def _get_BFSK_word_boundaries(self):
-        n_bits = N_SYMBOLS_SAMD21 - 1
-        sr = self.samplerate
-        wwp = self._get_word_width_parameters()
-        pulse_position = self._get_pulse_position()
-        # search_start_position = wwp['search_start_position']
-        search_end_position = wwp['search_end_position']
-        word_width_threshold = wwp['word_width_threshold']
-        word_extract = self.sound_extract[pulse_position :
-            search_end_position]
-        logger.debug('word left boundary search position: %i relative to extract'%
-            (search_end_position))
-        logger.debug('extract starting at %i in file (Decoder.sound_extract_position)'%
-                self.sound_extract_position)
-        flipped_extract = np.flip(np.abs(word_extract))
-        right_boundary = len(word_extract) - \
-            np.argmax(flipped_extract > word_width_threshold)  + \
-                pulse_position
-        # left_boundary = np.argmax(
-        #     np.abs(word_extract) > word_width_threshold)  + \
-        #     search_start_position
-        left_boundary = pulse_position
-        left_in_file = left_boundary + self.sound_extract_position
-        right_in_file = right_boundary + self.sound_extract_position
-        logger.debug('word boundaries: %i and %i in file'%
-                                (left_in_file, right_in_file))
-        eff_symbol_length = 1e3*(right_boundary-left_boundary)/(n_bits*sr)
-        logger.debug('effective symbol length %.4f ms '%
-                                eff_symbol_length)
-        logger.debug('presumed symbol length %.4f ms '%SYMBOL_LENGTH)
-        relative_error = (eff_symbol_length-SYMBOL_LENGTH)/SYMBOL_LENGTH
-        status = True
-        if relative_error > SYMBOL_LENGTH_TOLERANCE:
-            logger.error(
-                'actual symbol length differs too much: %.2f vs %.2f ms'%
-                (eff_symbol_length, SYMBOL_LENGTH))
-            # return None, None
-            status = False
-        logger.debug(' relative discrepancy %.4f%%'%(abs(100*relative_error)))
-        return status, left_boundary, right_boundary
-
-    def _get_BFSK_symbols_boundaries(self):
-        # returns indices of start of each slice and boundaries
-        pulse_position = self._get_pulse_position()
-        boundaries_OK, left_boundary, right_boundary = \
-                self._get_BFSK_word_boundaries()
-        if left_boundary is None:
-            return None, None, None ############################################
-        symbol_width_samples = \
-                float(right_boundary - left_boundary)/N_SYMBOLS_SAMD21
-        symbol_positions = symbol_width_samples * \
-                np.arange(float(0), float(N_SYMBOLS_SAMD21 + 1)) + \
-                pulse_position
-        int_symb_positions = symbol_positions.round().astype(int)
-        logger.debug('%i symbol positions %s samples in file'%
-                (
-                len(int_symb_positions),
-                int_symb_positions + self.sound_extract_position)
-                )
-        return int_symb_positions[:-1], left_boundary, right_boundary
-
-    def _values_from_bits(self, bits):
-        word_payload_bits_positions = {
-            'version':(0,2),
-            'clock source':(2,3),
-            'seconds':(3,9),
-            'minutes':(9,15),
-            'hours':(15,20),
-            'day':(20,25),
-            'month':(25,29),
-            'year offset':(29,34),
-            }
-        binary_words = { key : bits[slice(*value)]
-                for key, value 
-                in word_payload_bits_positions.items()
-                }
-        int_values = { key : self._get_int_from_binary_str(val)
-                for key, val                 in binary_words.items()
-                }
-        logger.debug(' Demodulated values %s'%int_values)
-        return int_values
-
-    def _slice_sound_extract(self, symbols_indices):
-        indices_left_shifted = deque(list(symbols_indices))
-        indices_left_shifted.rotate(-1)
-        all_intervals = list(zip(
-                                symbols_indices,
-                                indices_left_shifted
-                                ))
-        word_intervals = all_intervals[1:-1]
-        # [0, 11, 23, 31, 45] => [(11, 23), (23, 31), (31, 45)]
-        logger.debug('slicing intervals, word_intervals = %s'%
-                                                word_intervals)
-        # skip sample after pulse, start at BFSK word
-        filtered_sound_extract = self._band_pass_filter(self.sound_extract)
-        slices = [filtered_sound_extract[slice(*pair)]
-                            for pair in word_intervals]
-        np.set_printoptions(threshold=5)
-        # logger.debug('data slices: \n%s'%pprint.pformat(slices))
-        # raise Exception
+            # Two regions.
+            logger.debug('word is in two regions, will wrap past seconds')
+            # Consistency check: if not whole_word_is_in_extr
+            # check has been done so seconds are encoded in what s left
+            minimum_samples = round(self.samplerate*10*SYMBOL_LENGTH*1e-3)
+            if whats_left*self.samplerate < minimum_samples:
+                print('bug in _get_data_symbol():')
+                print(' whats_left*self.samplerate < minimum_samples')
+            # Should now build a whole 0.5 sec word by joining remaining data
+            # from previous second beep
+            left_piece = self.sound_extract[self.detected_pulse_position:]
+            one_second_before_idx = round(len(self.sound_extract) - self.samplerate)
+            length_needed = round(0.5*self.samplerate - len(left_piece))
+            length_needed += round(self.samplerate*SYMBOL_LENGTH*1e-3)
+            right_piece = self.sound_extract[one_second_before_idx:
+                                            one_second_before_idx + length_needed]
+            whole_word = np.concatenate((left_piece, right_piece))
+            logger.debug('two chunks lengths: %i %i samples'%(len(left_piece),
+                                                        len(right_piece)))
+        # search for word start (some jitter because of Teensy Audio Lib)
+        symbol_length = round(self.samplerate*SYMBOL_LENGTH*1e-3)
+        start = round(0.5*symbol_length) # half symbol
+        end = start + symbol_length
+        word_begining = whole_word[start:]
+        # word_one_bit = np.abs(word_begining)>self.pulse_detection_level
+        # N_ones = round(1.5*SYMBOL_LENGTH*1e-3*self.samplerate) # so it includes sync pulse
+        # word_one_bit = closing(word_one_bit, np.ones(N_ones))
+        gt_detection_level = np.argwhere(np.abs(word_begining)>self.pulse_detection_level)
+        # print(gt_detection_level)
+        # plt.plot(word_one_bit)
+        # plt.plot(word_begining/abs(np.max(word_begining)))
+        # plt.show()
+        word_start = gt_detection_level[0][0]
+        word_end = gt_detection_level[-1][0]
+        self.effective_word_duration = (word_end - word_start)/self.samplerate
+        logger.debug('effective_word_duration %f s'%self.effective_word_duration)
+        uCTRLR_error = self.effective_word_duration/((N_SYMBOLS -1)*SYMBOL_LENGTH*1e-3)
+        logger.debug('uCTRLR_error %f (time ratio)'%uCTRLR_error)
+        word_start += start # relative to Decoder extract
+        # check if gap is indeed less than TEENSY_MAX_LAG
+        silence_length = word_start
+        gap = silence_length - symbol_length
+        relative_gap = gap/(TEENSY_MAX_LAG*self.samplerate)
+        logger.debug('Audio update() gap between sync pulse and word start: ')
+        logger.debug('%.2f ms (max value %.2f)'%(1e3*gap/self.samplerate,
+                                    1e3*TEENSY_MAX_LAG))
+        logger.debug('relative audio_block gap %.2f'%(relative_gap))
+        if relative_gap > 1:
+            print('bug with relative_gap')
+        symbol_width_samples_theor = self.samplerate*SYMBOL_LENGTH*1e-3
+        symbol_width_samples_eff = self.effective_word_duration * \
+                                            self.samplerate/(N_SYMBOLS - 1)
+        logger.debug('symbol width %i theo; %i effective (samples)'%(
+                                    symbol_width_samples_theor,
+                                    symbol_width_samples_eff))
+        symbol_positions = symbol_width_samples_eff * \
+            np.arange(float(0), float(N_SYMBOLS - 1)) + word_start
+        # symbols_indices contains 34 start of symbols (samples)
+        symbols_indices = symbol_positions.round().astype(int)
+        if self.do_plots:
+            fig, ax = plt.subplots()
+            ax.plot(whole_word, marker='o', markersize='1',
+                linewidth=1.5,alpha=0.3, color='blue' )
+            xt = ax.get_xaxis_transform()
+            for x in symbols_indices:
+                ax.vlines(x, 0, 1,
+                    transform=xt,
+                linewidth=0.6, colors='green')
+                ax.set_title('Slicing the 34 bits word:')
+            plt.show()
+        slice_width = round(SYMBOL_LENGTH*1e-3*self.samplerate)
+        slices = [whole_word[i:i+slice_width] for i in symbols_indices]
         return slices
 
     def _get_main_frequency(self, symbol_data):
@@ -777,195 +508,6 @@ class Decoder:
         freq_in_hertz = abs(freq * self.samplerate)
         return int(round(freq_in_hertz))
 
-    # def _get_bit_from_freq(self, freq):
-    #     if math.isclose(freq, F1, abs_tol=FSK_TOLERANCE):
-    #         return '0'
-    #     if math.isclose(freq, F2, abs_tol=FSK_TOLERANCE):
-    #         return '1'
-    #     else:
-    #         return None
-
-    def _get_bit_from_freq(self, freq):
-        mid_FSK = 0.5*(F1 + F2)
-        return '1' if freq > mid_FSK else '0'
-
-    def _get_int_from_binary_str(self, string_of_01s):
-        return int(''.join(reversed(string_of_01s)),2)
-        # LSB is leftmost in TicTacCode
-
-    def _demod_values_are_OK(self, values_dict):
-        # TODO: use _get_timedate_from_dict rather (catching any ValueError)
-        ranges = {
-            'seconds': range(60),
-            'minutes': range(60),
-            'hours': range(24),
-            'day': range(1,32), # 32 ?
-            'month': range(1,13),
-            }
-        for key in ranges:
-            val = values_dict[key]
-            ok =  val in ranges[key]
-            logger.debug(
-                'checking range for %s: %i, Ok? %s'%(key, val, ok))
-            if not ok:
-                logger.error('demodulated value is out of range')
-                return False
-        return True
-
-    def _plot_slices(self, sync_pulse, symbols_indices, word_lft, word_rght,
-                        title=None, filename=None):
-        # save figure in filename if set, otherwise
-        # start an interactive plot, title is for matplotlib
-        signal = self.sound_extract
-        # signal = self._band_pass_filter(signal)
-        start = self.sound_extract_position
-        x_signal_in_file = range(
-                                start,
-                                start + len(signal)
-                                )
-        wwp = self._get_word_width_parameters()
-        start_silent_zone, end_silent_zone = self._get_silent_zone_indices()
-        search_end_position = wwp['search_end_position'] + start
-        logger.debug('doing slice plot')
-        fig, ax = plt.subplots()
-        plt.title(title)
-        ax.plot(
-            x_signal_in_file, signal,
-            marker='.', markersize='1',
-            linewidth=0.3, color='purple', alpha=0.3)
-        yt = ax.get_yaxis_transform()
-        ax.hlines(
-            wwp['word_width_threshold'], 0, 1, 
-            transform=yt, linewidth=0.6, colors='green')
-        ax.hlines(
-            0, 0, 1, 
-            transform=yt, linewidth=0.6, colors='black')
-        ax.hlines(
-            -wwp['word_width_threshold'], 0, 1, 
-            transform=yt, linewidth=0.6, colors='green')
-        pulse_level = self._get_pulse_detection_level()
-        ax.hlines(
-            pulse_level, 0, 1, 
-            transform=yt, linewidth=0.6, colors='blue')
-        ax.hlines(
-            -pulse_level, 0, 1, 
-            transform=yt, linewidth=0.6, colors='blue')
-        xt = ax.get_xaxis_transform()
-        # ax.vlines(
-        #     search_start_position,
-        #     0, 1, transform=xt, linewidth=0.6, colors='blue')
-        ax.vlines(
-            search_end_position,
-            0, 1, transform=xt, linewidth=0.6, colors='blue')
-        ax.plot(
-            [sync_pulse + start], [0],
-            marker='D', markersize='7',
-            linewidth=0.3, color='blue', alpha=0.3)
-        ax.plot(
-            [start_silent_zone + start], [0],
-            marker='>', markersize='10',
-            linewidth=0.3, color='green', alpha=0.3)
-        ax.plot(
-            [end_silent_zone + start], [0],
-            marker='<', markersize='10',
-            linewidth=0.3, color='green', alpha=0.3)
-        boundaries_OK, word_lft, word_rght = \
-            self._get_BFSK_word_boundaries()
-        ax.vlines(
-            word_lft + start, 0, 1,
-            transform=ax.get_xaxis_transform(),
-            linewidth=0.6, colors='red')
-        ax.vlines(
-            word_rght + start, 0, 1, 
-            transform=ax.get_xaxis_transform(),
-            linewidth=0.6, colors='red')
-        for x in symbols_indices + self.sound_extract_position:
-            ax.vlines(
-            x, 0, 1,
-            transform=ax.get_xaxis_transform(),
-            linewidth=0.3, colors='green')
-        ax.set_xlabel(
-            'samples in file')
-        plt.xlim(
-            [sync_pulse - 300 + start, wwp['search_end_position'] + 400 + start])
-        if filename == None:
-            plt.show()
-        else:
-            plt.ylim(
-                [-1.5*wwp['word_width_threshold'],
-                1.1*signal.max()])
-            height = 1000
-            plt.savefig(
-                filename,
-                format='png',
-                dpi=height/fig.get_size_inches()[1])
-            plt.close()
-        logger.debug('done slice plot')
-
-    def _band_pass_filter(self, data):
-        # return filtered data
-        def _bandpass(data: np.ndarray, edges: list[float], sample_rate: float, poles: int = 5):
-            sos = scipy.signal.butter(poles, edges, 'bandpass', fs=sample_rate, output='sos')
-            filtered_data = scipy.signal.sosfiltfilt(sos, data)
-            return filtered_data
-        sample_rate = self.samplerate
-        times = np.arange(len(data))/sample_rate
-        return _bandpass(data, [BPF_LOW_FRQ, BPF_HIGH_FRQ], sample_rate)
-
-    def get_time_in_sound_extract(self, plots):
-        if self.sound_extract is None:
-            return None ########################################################
-        if plots:
-            self.make_silence_analysis_plot()
-        pulse_position = self._detect_sync_pulse_position()
-        pulse_pos_in_file = pulse_position + self.sound_extract_position
-        pulse_position_sec = pulse_pos_in_file/self.samplerate
-        logger.debug('found sync pulse at sample %i in file'%pulse_pos_in_file)
-        symbols_indices, word_lft, word_rght = \
-            self._get_BFSK_symbols_boundaries()
-        if plots:
-            title = 'Bit slicing at %s, %.2f s'%(pulse_pos_in_file,
-                    pulse_position_sec)
-            # self.make_silence_analysis_plot()
-            logger.debug('calling _plot_slices()')
-            self._plot_slices(pulse_position, symbols_indices, word_lft,
-                                word_rght, title)
-        if symbols_indices is None:
-            return None ########################################################
-        sliced_data = self._slice_sound_extract(symbols_indices)
-        frequencies = [self._get_main_frequency(data_slice)
-                            for data_slice
-                            in sliced_data
-                            ]
-        logger.debug('frequencies = %s'%frequencies)
-        sr = self.samplerate
-        n_bits = N_SYMBOLS_SAMD21 - 1
-        eff_symbol_length = 1e3*(word_rght-word_lft)/(n_bits*sr)
-        length_ratio = eff_symbol_length / SYMBOL_LENGTH
-        logger.debug('symbol length_ratio (eff/supposed) %f'%length_ratio)
-        corrected_freq = np.array(frequencies)*length_ratio
-        logger.debug('corrected freq (using symbol length) = %s'%corrected_freq)
-        bits = [self._get_bit_from_freq(f) for f in corrected_freq]
-        for i, bit in enumerate(bits):
-            if bit == None:
-                logger.warning('cant decode frequency %i for bit at %i-%i'%(
-                                corrected_freq[i],
-                                symbols_indices[i],
-                                symbols_indices[i+1]))
-        if None in bits:
-            return None ########################################################
-        bits_string = ''.join(bits)
-        logger.debug('bits = %s'%bits_string)
-        time_values = self._values_from_bits(bits_string)
-        time_values['pulse at'] = (pulse_position +
-                                    self.sound_extract_position -
-                                    SAMD21_LATENCY*1e-6*self.samplerate)
-        time_values['clock source'] = 'GPS' \
-            if time_values['clock source'] == 1 else 'RTC'
-        if self._demod_values_are_OK(time_values):
-            return time_values
-        else:
-            return None
 
 class Recording:
     """
@@ -1047,7 +589,7 @@ class Recording:
 
     """
 
-    def __init__(self, media):
+    def __init__(self, media, do_plots=False):
         """
         If multifile recording, AVfilename is sox merged audio file;
         Set AVfilename string and check if file exists, does not read
@@ -1097,6 +639,7 @@ class Recording:
         self.final_synced_file = None
         self.synced_audio = None
         self.new_rec_name = media.path.name
+        self.do_plots = do_plots
         logger.debug('__init__ Recording object %s'%self.__repr__())
         logger.debug(' in directory %s'%self.AVpath.parent)
         recording_init_fail = ''
@@ -1119,7 +662,7 @@ class Recording:
         elif self.get_duration() < MINIMUM_LENGTH:
             recording_init_fail = 'file too short, %f s\n'%self.get_duration()
         if recording_init_fail == '': # success
-            self.decoder = Decoder(self)
+            self.decoder = Decoder(self, do_plots)
             # self._set_multi_files_siblings()
             self._check_for_camera_error_correction()
         else:
@@ -1171,7 +714,7 @@ class Recording:
         """
         if self.valid_sound:
             val = sox.file_info.duration(_pathname(self.valid_sound))
-            logger.debug('duration of valid_sound %f'%val)
+            logger.debug('sox duration of valid_sound %f for %s'%(val,_pathname(self.valid_sound)))
             return val #########################################################
         else:
             if self.probe is None:
@@ -1181,7 +724,7 @@ class Recording:
             except:
                 logger.error('oups, cant find duration from ffprobe')
                 raise Exception('stopping here')
-            logger.debug('ffprobed duration is: %f sec'%probed_duration)
+            logger.debug('ffprobed duration is: %f sec for %s'%(probed_duration, self))
             return probed_duration # duration in s
 
     def get_original_duration(self):
@@ -1238,16 +781,16 @@ class Recording:
         end = self.get_end_time()
         return start < datetime and datetime < end
 
-    def _find_time_around(self, time, plots):
+    def _find_time_around(self, time):
         """        
         Actually reads sound data and tries to decode it
         through decoder object, if successful  return a time dict, eg:
-        {'version': 0, 'clock source': 'GPS', 'seconds': 44, 'minutes': 57,
+        {'version': 0, 'seconds': 44, 'minutes': 57,
         'hours': 19, 'day': 1, 'month': 3, 'year offset': 1, 
         'pulse at': 670451.2217 }
         otherwise return None
         """        
-        if time < 0:
+        if time < 0: # negative = referenced from the end
             there = self.get_duration() + time
         else:
             there = time
@@ -1255,7 +798,7 @@ class Recording:
         if self.TicTacCode_channel is None:
             return None
         else:
-            return self.decoder.get_time_in_sound_extract(plots)
+            return self.decoder.get_time_in_sound_extract()
 
     def _get_timedate_from_dict(self, time_dict):
         try:
@@ -1291,8 +834,6 @@ class Recording:
 
         Returns
         -------
-        TYPE
-            DESCRIPTION.
 
         """
         if t1 == None or t2 == None:
@@ -1362,7 +903,7 @@ class Recording:
         t2 = later_recording.get_start_time()
         return t2 - t1
 
-    def get_start_time(self, plots=False):
+    def get_start_time(self):
         """
         Try to decode a TicTacCode_channel at start AND finish;
         if successful, returns a datetime.datetime instance;
@@ -1372,7 +913,7 @@ class Recording:
         if self.start_time is not None:
             return self.start_time #############################################
         cached_times = {}
-        def find_time(t_sec, plots=False):
+        def find_time(t_sec):
             time_k = int(t_sec)
             # if cached_times.has_key(time_k):
             if CACHING and time_k in cached_times:
@@ -1380,7 +921,7 @@ class Recording:
                 return cached_times[time_k] ####################################
             else:
                 logger.debug('_find_time_around() for t=%s s not cached'%time_k)
-                new_t = self._find_time_around(t_sec, plots)
+                new_t = self._find_time_around(t_sec)
                 cached_times[time_k] = new_t
                 return new_t
         for i, pair in enumerate(TRIAL_TIMES):
@@ -1393,12 +934,12 @@ class Recording:
                 logger.warning('More than one trial: #%i/%i'%(i+1,
                                         len(TRIAL_TIMES)))
             # time_around_beginning = self._find_time_around(near_beg)
-            time_around_beginning = find_time(near_beg, plots)
+            time_around_beginning = find_time(near_beg)
             if self.TicTacCode_channel is None:
                 return None ####################################################
             logger.debug('Trial #%i, end at %f'%(i+1, near_end))
             # time_around_end = self._find_time_around(near_end)
-            time_around_end = find_time(near_end, plots)
+            time_around_end = find_time(near_end)
             logger.debug('trial result, time_around_beginning:\n   %s'%
                     (time_around_beginning))
             logger.debug('trial result, time_around_end:\n   %s'%
@@ -1436,133 +977,6 @@ class Recording:
             self.valid_sound = self.AVpath
         return start_UTC
 
-    # def _strip_TTC_and_Null(self) -> tempfile.NamedTemporaryFile:
-    #     """        
-    #     TTC is stripped from original audio and a tempfile.NamedTemporaryFile is
-    #     returned. If the original audio is stereo, this is simply the audio
-    #     without the TicTacCode channel, so this fct returns a mono wav
-    #     tempfile. But if the original audio is multitrack, two possibilities:
-
-    #         A- there's a track.txt file declaring null channels (with '0' tags)
-    #         then those tracks are excluded too (a check is done those tracks
-    #         have low signal and warns the user otherwise) 
-
-    #         B- it's a multitrack recording but without track declaration
-    #         (no track.txt was found in the device folder): all the tracks are
-    #         returned into a multiwav tempfile (except TTC).
-
-    #     Notes:
-    #         'track.txt' is defined in device_scanner.TRACKSFN 
-
-    #         Beware of track indexing: sox starts indexing tracks at 1 but code
-    #         here uses zero based indexing.
-    #     """
-    #     tracks_file = self.device.folder/device_scanner.TRACKSFN
-    #     input_file = _pathname(self.AVpath)
-    #     # n_channels = sox.file_info.channels(input_file) # eg 2
-    #     n_channels = self.device.n_chan
-    #     sox_TicTacCode_channel = self.TicTacCode_channel + 1 # sox start at 1
-    #     if n_channels == 2:
-    #         logger.debug('stereo, so only excluding TTC (ZB idx) %i'%
-    #                 self.TicTacCode_channel)
-    #         return self._sox_strip(input_file, [self.TicTacCode_channel]) ######
-    #     #
-    #     # First a check is done if the ttc tracks concur: the track detected
-    #     # by the Decoder class, stored in Recording.TicTacCode_channel VS the
-    #     # track declared by the user, Tracks.ttc (see device_scanner.py). If
-    #     # not, warn the user and exit.
-    #     trax = self.device.tracks # a Tracks dataclass instance, if any
-    #     logger.debug('trax %s'%trax)
-    #     if trax == None:
-    #         return self._sox_strip(input_file, [self.TicTacCode_channel]) ######
-    #     else:
-    #         logger.debug('ttc channel declared for the device: %i, ttc detected: %i, non zero base indexing'%
-    #                     (trax.ttc, sox_TicTacCode_channel))
-    #     if trax.ttc != sox_TicTacCode_channel: # warn and quit
-    #         print('Error: TicTacCode channel detected is [gold1]%i[/gold1]'%
-    #             sox_TicTacCode_channel, end=' ')
-    #         print('and the file [gold1]%s[/gold1] specifies channel [gold1]%i[/gold1],'%
-    #             (tracks_file, trax.ttc))
-    #         print('Please correct the discrepancy and rerun. Quitting.')
-    #         sys.exit(1)
-    #     track_is_declared_audio = [ tag not in ['ttc','0','tc']
-    #                                 for tag in trax.rawtrx]
-    #     logger.debug('from tracks_file %s'%tracks_file)
-    #     logger.debug('track_is_declared_audio (not ttc or 0): %s'%
-    #                                             track_is_declared_audio)
-    #     # Now find out which files are silent, ie those with sox stats "RMS lev
-    #     # db" value inferior to DB_RMS_SILENCE_SOX (typ -50 -60 dbFS) from the
-    #     # sox "stat" command. Ex output belwow:
-    #     #
-    #     # sox input.wav -n channels stats -w 0.01
-    #     #
-    #     #              Overall     Ch1       Ch2       Ch3       Ch4  
-    #     # DC offset  -0.000047 -0.000047 -0.000047 -0.000016 -0.000031
-    #     # Min level  -0.060913 -0.060913 -0.048523 -0.036438 -0.002777
-    #     # Max level   0.050201  0.050201  0.048767  0.039032  0.002838
-    #     # Pk lev dB     -24.31    -24.31    -26.24    -28.17    -50.94
-    #     # RMS lev dB    -40.33    -55.29    -53.70    -34.41    -59.75 <- this line
-    #     # RMS Pk dB     -28.39    -28.39    -30.90    -31.20    -55.79
-    #     # RMS Tr dB     -97.42    -79.66    -75.87    -97.42    -96.09
-    #     # Crest factor       -     35.41     23.61      2.05      2.76
-    #     # Flat factor     6.93      0.00      0.00      0.97     10.63
-    #     # Pk count        10.2         2         2        17        20
-    #     # Bit-depth      12/16     12/16     12/16     12/16      8/16
-    #     # Num samples    11.2M
-    #     # Length s     232.780
-    #     # Scale max   1.000000
-    #     # Window s       0.010
-    #     args = ['sox', input_file, '-n', 'channels', 'stats', '-w', '0.01']
-    #     _, _, stat_output = sox.core.sox(args)
-    #     logger.debug('sox stat output: \n%s'%stat_output)
-    #     sox_RMS_lev_dB = stat_output.split('\n')[5].split()[4:]
-    #     logger.debug('Rec %s'%self)
-    #     logger.debug('Sox RMS %s, n_channels: %i'%(sox_RMS_lev_dB, n_channels))
-    #     # valid audio is non silent and not ttc
-    #     track_is_active = [float(db) > DB_RMS_SILENCE_SOX
-    #         if idx + 1 != sox_TicTacCode_channel else False
-    #         for idx, db in enumerate(sox_RMS_lev_dB)]
-    #     logger.debug('track_is_active %s'%track_is_active)
-    #     # Stored in self.device.tracks and as declared by the user, a track is
-    #     # either:
-    #     #
-    #     # - an active track (because a name was given to it)
-    #     # - the ttc track (as identified by the user)
-    #     # - a muted track (declared by a "0" in tracks.txt)
-    #     #
-    #     # the following checks active tracks are effectively non silent and
-    #     # muted tracks are effectively silent (warn the user if not but
-    #     # proceed, giving priority to status declared in the tracks.txt file.
-    #     # eg a non silent track will be discarded if the user tagged it with
-    #     # a "0")
-    #     declared_and_detected_are_same = all([a==b for a,b
-    #         in zip(track_is_declared_audio, track_is_active)])
-    #     logger.debug('declared_and_detected_are_same: %s'%
-    #                             declared_and_detected_are_same)
-    #     if not declared_and_detected_are_same:
-    #         print('Warning, the file [gold1]%s[/gold1] specifies channel usage'%
-    #             (tracks_file))
-    #         print('and some muted tracks are not silent (or the inverse, see below),')
-    #         print('will proceed but if it\'s an error do necessary corrections and rerun.\n')
-    #         table = Table(title="Tracks status")
-    #         table.add_column("track #", justify="center", style='gold1')
-    #         table.add_column("RMS Level", justify="center", style='gold1')
-    #         table.add_column("Declared", justify="center", style='gold1')
-    #         for n in range(n_channels):
-    #             table.add_row(str(n+1), '%.0f dBFS'%float(sox_RMS_lev_dB[n]),
-    #                 trax.rawtrx[n])
-    #         console = Console()
-    #         console.print(table)
-    #     if trax:
-    #         excluded_channels = [i for i in range(n_channels)
-    #             if not track_is_declared_audio[i]]
-    #     else:
-    #         excluded_channels = [self.TicTacCode_channel]
-    #     logger.debug('excluded_channels %s (ZB idx)'%excluded_channels)
-    #     return self._sox_strip(input_file, excluded_channels)
-
-
-
     def _sox_strip(self, audio_file, excluded_channels) -> tempfile.NamedTemporaryFile:
         # building dict according to pysox.remix format.
         # https://pysox.readthedocs.io/en/latest/api.html#sox.transform.Transformer.remix
@@ -1649,6 +1063,7 @@ class Recording:
     def get_samplerate(self):
         # return int samplerate (nominal)
         string = self._ffprobe_audio_stream()['sample_rate']
+        logger.debug('ffprobe samplerate: %s'%string)
         return eval(string) # eg eval(24000/1001)
 
     def get_framerate(self):
@@ -1717,13 +1132,16 @@ class Recording:
 
     def _read_sound_find_TicTacCode(self, time_where, chunk_length):
         """
-        Loads audio data reading from self.AVpath;
-        Split data into channels if stereo;
-        Send this data to Decoder object with set_sound_extract_and_sr() to find
+        If this is called for the first time for the recording, it loads audio
+        data reading from self.AVpath; Split data into channels if stereo; Send
+        this data to Decoder object with set_sound_extract_and_sr() to find
         which channel contains a TicTacCode track and sets TicTacCode_channel
-        accordingly: a tuple (#file, #chan). On exit, self.decoder.sound_extract
-        contains TicTacCode data ready to be demodulated. If not, self.TicTacCode_channel
-        is set to None.
+        accordingly (index of channel). On exit, self.decoder.sound_extract
+        contains TicTacCode data ready to be demodulated. If not,
+        self.TicTacCode_channel is set to None.
+
+        If this has been called before (checking self.TicTacCode_channel) then
+        is simply read the audio in and calls set_sound_extract_and_sr(). 
 
         Args:
             time_where : float
@@ -1735,7 +1153,8 @@ class Recording:
             self.decoder.set_sound_extract_and_sr()
 
         Sets:
-            self.TicTacCode_channel
+            self.TicTacCode_channel = index of TTC chan
+            self.device.ttc  = index of TTC chan
 
         Returns:
             this Recording instance
@@ -1751,14 +1170,15 @@ class Recording:
             return #############################################################
         logger.debug('will read around %.2f sec'%time_where)
         dryrun = (ffmpeg
-            .input(str(path), ss=time_where, t=chunk_length)
+            .input(str(path))
             .output('pipe:', format='s16le', acodec='pcm_s16le')
             .get_args())
         dryrun = ' '.join(dryrun)
         logger.debug('using ffmpeg-python built args to pipe wav file into numpy array:\nffmpeg %s'%dryrun)
         try:
             out, _ = (ffmpeg
-                .input(str(path), ss=time_where, t=chunk_length)
+                # .input(str(path), ss=time_where, t=chunk_length)
+                .input(str(path))
                 .output('pipe:', format='s16le', acodec='pcm_s16le')
                 .global_args("-loglevel", "quiet")
                 .global_args("-nostats")
@@ -1766,28 +1186,54 @@ class Recording:
                 .run(capture_stdout=True))
             data = np.frombuffer(out, np.int16)
         except ffmpeg.Error as e:
-            print('error',e.stderr)        
+            print('error',e.stderr)
+        sound_data_var = np.std(data)
+        logger.debug('extracting sound, ffmpeg output:%s with variance %f'%(data,
+                                                                sound_data_var))
         sound_extract_position = int(self.get_samplerate()*time_where) # from sec to samples
         n_chan = self.get_audio_channels_nbr()
         if n_chan == 1 and not self.is_video():
             logger.warning('file is sound mono')
+        if np.isclose(sound_data_var, 0, rtol=1e-2):
+            logger.warning("ffmpeg can't extract audio from %s"%self.AVpath)
+        # from 1D  interleaved channels to [chan1, chan2, chanN]
         all_channels_data = data.reshape(int(len(data)/n_chan),n_chan).T
-        for i_chan, chan_dat in enumerate(all_channels_data):
-            logger.debug('testing chan %i'%i_chan)
+        if self.TicTacCode_channel == None:
+            logger.debug('first call, will loop through all %i channels'%len(
+                                        all_channels_data))
+            for i_chan, chan_dat in enumerate(all_channels_data):
+                logger.debug('testing chan %i'%i_chan)
+                start_idx = round(time_where*self.get_samplerate())
+                extract_length = round(chunk_length*self.get_samplerate())
+                end_idx = start_idx + extract_length
+                extract_audio_data = chan_dat[start_idx:end_idx]
+                decoder.set_sound_extract_and_sr(
+                        extract_audio_data,
+                        self.get_samplerate(),
+                        sound_extract_position
+                        )
+                if decoder.extract_seems_TicTacCode():
+                    self.TicTacCode_channel = i_chan
+                    self.device.ttc = i_chan
+                    logger.debug('found TicTacCode channel: chan #%i'%
+                                    self.TicTacCode_channel)
+                    return self ################################################
+            # end of loop: none found
+            # self.TicTacCode_channel = None # was None already 
+            logger.warning('found no TicTacCode channel')
+        else:
+            logger.debug('been here before, TTC chan is %i'%
+                                                self.TicTacCode_channel)
+            start_idx = round(time_where*self.get_samplerate())
+            extract_length = round(chunk_length*self.get_samplerate())
+            end_idx = start_idx + extract_length
+            chan_dat = all_channels_data[self.TicTacCode_channel]
+            extract_audio_data = chan_dat[start_idx:end_idx]
             decoder.set_sound_extract_and_sr(
-                    chan_dat,
+                    extract_audio_data,
                     self.get_samplerate(),
                     sound_extract_position
                     )
-            if decoder.extract_seems_TicTacCode():
-                self.TicTacCode_channel = i_chan
-                self.device.ttc = i_chan
-                logger.debug('find TicTacCode channel, chan #%i'%
-                                self.TicTacCode_channel)
-                return self ####################################################
-        # end of loop: none found
-        self.TicTacCode_channel = None
-        logger.warning('found no TicTacCode channel')
         return self
     
     def seems_to_have_TicTacCode_at_beginning(self):