Added ESP32 side of the transceiver

2026-06-04 17:01:14 +03:00
parent bcf7bede0f
commit fa830b2c37
2303 changed files with 497306 additions and 0 deletions
@@ -0,0 +1,153 @@
+Metadata-Version: 2.1
+Name: wavio
+Version: 0.0.9
+Summary: A Python module for reading and writing WAV files using numpy arrays.
+Home-page: https://github.com/WarrenWeckesser/wavio
+Author: Warren Weckesser
+License: BSD
+Keywords: wav numpy
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: numpy >=1.19.0
+
+wavio
+=====
+
+``wavio`` is a Python module that defines two functions:
+
+* ``wavio.read`` reads a WAV file and returns an object that holds the
+  sampling rate, sample width (in bytes), and a numpy array containing the
+  data.
+* ``wavio.write`` writes a numpy array to a WAV file, optionally using a
+  specified sample width.
+
+The functions can read and write 8-, 16-, 24- and 32-bit integer WAV files.
+
+The module uses the ``wave`` module in Python's standard library, so it has
+the same limitations as that module.  In particular, the ``wave`` module
+does not support compressed WAV files, and it does not handle floating
+point WAV files.  When floating point data is passed to ``wavio.write`` it
+is converted to integers before being written to the WAV file.
+
+``wavio`` requires Python 3.7 or later.
+
+``wavio`` depends on numpy (http://www.numpy.org).  NumPy version 1.19.0 or
+later is required.    The unit tests in ``wavio`` require ``pytest``.
+
+The API of the functions in ``wavio`` should not be considered stable.  There
+may be backwards-incompatible API changes between releases.
+
+*Important notice*
+
+In version 0.0.5, the data handling in ``wavio.write`` has been changed in
+a backwards-incompatible way.  The API for scaling the input in 0.0.4 was
+a flexible interface that only its creator could love.  The new API is
+simpler, and it is hoped that it does the right thing by default in
+most cases.  In particular:
+
+* When the input data is an integer type, the values are not scaled or
+  shifted.  The only change that might happen is the data will be clipped
+  if the values do not fit in the output integer type.
+* If the input data is a floating point type, ``sampwidth`` must be given.
+  The default behavior is to scale input values in the range [-1.0, 1.0]
+  to the output range [min_int+1, max_int], where min_int and max_int are
+  the minimum and maximum values of the output data type determined by
+  ``sampwidth``.  See the description of ``scale`` in the docstring of
+  ``wavio.write`` for more options.  Regardless of the value of ``scale``,
+  the float input 0.0 is always mapped to the midpoint of the output type;
+  ``wavio.write`` will not translate the values up or down.
+* A warning is now generated if any data values are clipped.  A parameter
+  allows the generation of the warning to be disabled or converted to an
+  exception.
+
+Examples
+--------
+
+The following examples are also found in the docstring of ``wavio.write``.
+
+Create a 3 second 440 Hz sine wave, and save it in a 24-bit WAV file.
+
+    >>> import numpy as np
+    >>> import wavio
+
+    >>> rate = 22050           # samples per second
+    >>> T = 3                  # sample duration (seconds)
+    >>> n = int(rate*T)        # number of samples
+    >>> t = np.arange(n)/rate  # grid of time values
+
+    >>> f = 440.0              # sound frequency (Hz)
+    >>> x = np.sin(2*np.pi * f * t)
+
+`x` is a single sine wave with amplitude 1, so we can use the default
+`scale`.
+
+    >>> wavio.write("sine24.wav", x, rate, sampwidth=3)
+
+Create a file that contains the 16 bit integer values -10000 and 10000
+repeated 100 times.  Use a sample rate of 8000.
+
+    >>> x = np.empty(200, dtype=np.int16)
+    >>> x[::2] = -10000
+    >>> x[1::2] = 10000
+    >>> wavio.write("foo.wav", x, 8000)
+
+Check that the file contains what we expect.  The values are checked
+for exact equality.  The input was an integer array, so the values are
+not scaled.
+
+    >>> w = wavio.read("foo.wav")
+    >>> np.all(w.data[:, 0] == x)
+    True
+
+Write floating point data to a 16 bit WAV file.  The floating point
+values are assumed to be within the range [-2, 2], and we want the
+values 2 and -2 to correspond to the full output range, even if the
+actual values in the data do not fill this range.  We do that by
+specifying `scale=2`.
+
+`T`, `rate` and `t` are from above.  The data is the sum of two
+sinusoids, with frequencies 440 and 880 Hz, modulated by a parabolic
+curve that is zero at the start and end of the data.
+
+    >>> envelope = (4/T**2)*(t * (T - t))
+    >>> omega1 = 2*np.pi*440
+    >>> omega2 = 2*np.pi*880
+    >>> y = envelope*(np.sin(omega1*t) + 0.3*np.sin(omega2*t + 0.2))
+    >>> y.min(), y.max()
+    (-1.1745469775555515, 1.093833464065767)
+
+Write the WAV file, with `scale=2`.
+
+    >>> wavio.write('harmonic.wav', y, rate, sampwidth=2, scale=2)
+
+Check the minimum and maximum integers that were actually written
+to the file:
+
+    >>> w = wavio.read("harmonic.wav")
+    >>> w.data.min(), w.data.max()
+    (-19243, 17921)
+
+If we want the WAV file to use as much of the range of the output
+integer type as possible (while still mapping 0.0 in the input to 0 in
+the output), we set `scale="auto"`.
+
+    >>> wavio.write('harmonic_full.wav', y, rate, sampwidth=2, scale="auto")
+
+    >>> w = wavio.read('harmonic_full.wav')
+    >>> w.data.min(), w.data.max()
+    (-32768, 30517)
+
+-----
+
+Author:     Warren Weckesser
+
+Repository: https://github.com/WarrenWeckesser/wavio
+
+License:    BSD 2-clause (http://opensource.org/licenses/BSD-2-Clause)