v0.4.0rc1

.github/workflows/tests.yml

@@ -14,7 +14,7 @@ jobs:
       matrix:
         platform:
           - ubuntu-latest
-        python-version: ['3.9', '3.10', '3.11', '3.12']
+        python-version: ['3.10', '3.11', '3.12']
 
     steps:
     - uses: actions/checkout@v3

.gitignore

@@ -5,4 +5,5 @@ python_adc_eval.egg-info
 dist
 .ruff_cache
 .coverage
+.secret
 build

README.rst

@@ -42,7 +42,8 @@ Given an array of values representing the output of an ADC, the spectrum can be
         leak=<adjacent bins to filter>,
         window=<window type (rectangular/hanning)>,
         no_plot=<True/False>,
-        yaxis=<"power"/"fullscale">
+        yaxis=<"power"/"fullscale"/"magnitude">,
+        single_sided=<True/False>
     )
 
 

__init__.py

@@ -0,0 +1 @@
+"""Init file for tests."""

adc_eval/__init__.py

@@ -1,5 +1 @@
 """Initialization file for module."""
-
-from . import spectrum
-from . import converters
-from . import signals

adc_eval/adcs/__init__.py

@@ -0,0 +1 @@
+"""Initialization file for module."""

adc_eval/adcs/basic.py

@@ -0,0 +1,152 @@
+"""Basic ADC models."""
+
+import numpy as np
+
+
+def dac(samples, nbits=8, vref=1):
+    """Digital to analog converter."""
+    quants = 2**nbits
+    dv = vref / quants
+    return samples * dv
+
+
+class ADC:
+    """
+    Generic ADC Class.
+
+    Parameters
+    ----------
+    nbits : int, default=8
+        Number of bits for the ADC.
+    fs : int or float, default=1
+        Sample rate for the ADC in Hz.
+    vref : int or float, default=1
+        Reference level of the ADC in Volts ([0, +vref] conversion range).
+    seed : int, default=1
+        Seed for random variable generation.
+    **kwargs
+        Extra arguments.
+
+    Attributes
+    -------
+    vin : float
+        Sets or returns the current input voltage level. Assumed +/-vref/2 input
+    vlsb : float
+        LSB voltage of the converter. vref/2^nbits
+    noise : float, default=0
+        Sets or returns the stdev of the noise generated by the converter.
+    mismatch : float, default=0
+        Sets or returns the stdev of the mismatch of the converter.
+    offset : tuple of float, default=(0, 0)
+        Sets the (mean, stdev) of the offset of the converter.
+    gain_error : tuple of float, default=(0, 0)
+        Sets the (mean, stdev) of the gain error of the converter.
+    distortion : list of float, default=[1]
+        Sets the harmonic distortion values with index=0 corresponding to HD1.
+        Example: For unity gain and only -30dB of HD3, input is [1, 0, 0.032]
+    dout : int
+        Digital output code for current vin value.
+
+    Methods
+    -------
+    run_step
+
+    """
+
+    def __init__(self, nbits=8, fs=1, vref=1, seed=1, **kwargs):
+        """Initialization function for Generic ADC."""
+        np.random.seed(seed)
+        self.nbits = nbits
+        self.fs = fs
+        self.vref = vref
+        self.seed = seed
+        self.err = {"noise": 0, "gain": 0, "dist": [1], "offset": 0, "mismatch": 0}
+        self.dbits = np.zeros(nbits)
+        self.dval = 0
+
+    @property
+    def vin(self):
+        """Return input value."""
+        return self._vin
+
+    @vin.setter
+    def vin(self, x):
+        """Set the input value."""
+        x += self.vref / 2
+        x = max(0, min(x, self.vref))
+        self._vin = x
+
+    @property
+    def vlsb(self):
+        """Return the LSB voltage."""
+        return self.vref / 2**self.nbits
+
+    @property
+    def noise(self):
+        """Return noise status."""
+        return self.err["noise"]
+
+    @noise.setter
+    def noise(self, stdev):
+        """Set noise stdev in Vrms."""
+        self.err["noise"] = stdev
+
+    @property
+    def mismatch(self):
+        """Return noise stdev."""
+        print("WARNING: 'mismatch' feature not implemented for this class.")
+        return False
+
+    @mismatch.setter
+    def mismatch(self, stdev):
+        """Set mismatch stdev."""
+        print("WARNING: 'mismatch' feature not implemented for this class.")
+        pass
+
+    @property
+    def offset(self):
+        """Return offset value."""
+        return self.err["offset"]
+
+    @offset.setter
+    def offset(self, values):
+        """Set offset mean and stdev."""
+        self.err["offset"] = np.random.normal(values[0], values[1])
+
+    @property
+    def gain_error(self):
+        """Return gain error status."""
+        return self.err["gain"]
+
+    @gain_error.setter
+    def gain_error(self, values):
+        """Set gain error mean and stdev."""
+        self.err["gain"] = np.random.normal(values[0], values[1])
+
+    @property
+    def distortion(self):
+        """Return distortion gains (1st-order indexed)."""
+        return self.err["dist"]
+
+    @distortion.setter
+    def distortion(self, gains):
+        """Set distortion gains (1st-order indexed)."""
+        self.err["dist"] = gains
+
+    @property
+    def dout(self):
+        """Return digital output code."""
+        return int(self.dval)
+
+    def run_step(self):
+        """Run a single ADC step."""
+        vinx = self.vin
+        dval = int(
+            min(max(int((2**self.nbits) * vinx / self.vref), 0), 2**self.nbits - 1)
+        )
+        bits = [int(x) for x in bin(dval)[2:]]
+
+        while len(bits) < self.nbits:
+            bits.insert(0, 0)
+        self.dbits = bits
+        self.dval = dval

adc_eval/adcs/sar.py

@@ -0,0 +1,130 @@
+"""SAR ADC models"""
+
+import numpy as np
+from adc_eval.adcs.basic import ADC
+
+
+class SAR(ADC):
+    """
+    SAR ADC Class.
+
+    Parameters
+    ----------
+    nbits : int, optional
+        Number of bits for the ADC. The default is 8.
+    fs : float, optional
+        Sample rate for the ADC in Hz. The default is 1Hz.
+    vref : float, optional
+        Reference level of the ADC in Volts ([0, +vref] conversion range). The default is 1.
+    seed : int, optional
+        Seed for random variable generation. The default is 1.
+    **kwargs
+        Extra arguments.
+        weights : list, optional
+            List of weights for SAR capacitors. Must be >= nbits. Defaults to binary weights.
+            MSB weight should be in index 0.
+
+    Attributes
+    -------
+    vin : float
+        Sets or returns the current input voltage level. Assumed +/-vref/2 input
+    vlsb : float
+        LSB voltage of the converter. vref/2^nbits
+    noise : float, default=0
+        Sets or returns the stdev of the noise generated by the converter.
+    weights : list
+        Sets or returns the capacitor weighting of the array. Default is binary weighting.
+    mismatch : float
+        Sets or returns the stdev of the mismatch of the converter. Default is no mismatch.
+    comp_noise : float
+        Sets or returns the stdev of the comparator noise. Default is no noise.
+    offset : tuple of float
+        Sets the (mean, stdev) of the offset of the converter. Default is no offset.
+    gain_error : tuple of float
+        Sets the (mean, stdev) of the gain error of the converter. Default is no gain error.
+    distortion : list of float
+        Sets the harmonic distortion values with index=0 corresponding to HD1.
+        Example: For unity gain and only -30dB of HD3, input is [1, 0, 0.032]
+    dout : int
+        Digital output code for current vin value.
+
+    Methods
+    -------
+    run_step
+
+    """
+
+    def __init__(self, nbits=8, fs=1, vref=1, seed=1, **kwargs):
+        """Initialization function for Generic ADC."""
+        super().__init__(nbits, fs, vref, seed)
+
+        self._mismatch = None
+        self._comp_noise = 0
+
+        # Get keyword arguments
+        self._weights = None
+        self.weights = kwargs.get("weights", self.weights)
+
+    @property
+    def weights(self):
+        """Returns capacitor unit weights."""
+        if self._weights is None:
+            self._weights = np.flip(2 ** np.linspace(0, self.nbits - 1, self.nbits))
+        return np.array(self._weights)
+
+    @weights.setter
+    def weights(self, values):
+        """Sets the capacitor unit weights."""
+        self._weights = np.array(values)
+        self.dbits = np.zeros(len(values))
+        if self._weights.size < self.nbits:
+            print(
+                f"WARNING: Capacitor weight array size is {self._weights.size} for {self.nbits}-bit ADC."
+            )
+        self.mismatch = self.err["mismatch"]
+
+    @property
+    def mismatch(self):
+        """Return noise stdev."""
+        if self._mismatch is None:
+            self._mismatch = np.zeros(self.weights.size)
+        return self._mismatch
+
+    @mismatch.setter
+    def mismatch(self, stdev):
+        """Sets mismatch stdev."""
+        self.err["mismatch"] = stdev
+        self._mismatch = np.random.normal(0, stdev, self.weights.size)
+        self._mismatch /= np.sqrt(self.weights)
+
+    @property
+    def comp_noise(self):
+        """Returns the noise of the comparator."""
+        return self._comp_noise
+
+    @comp_noise.setter
+    def comp_noise(self, value):
+        """Sets the noise of the comparator."""
+        self._comp_noise = value
+
+    def run_step(self):
+        """Run a single ADC step."""
+        vinx = self.vin
+
+        cweights = self.weights * (1 + self.mismatch)
+        cdenom = sum(cweights) + 1
+
+        comp_noise = np.random.normal(0, self.comp_noise, cweights.size)
+
+        # Bit cycling
+        vdac = vinx
+        for n, _ in enumerate(cweights):
+            vcomp = vdac - self.vref / 2 + comp_noise[n]
+            compout = vcomp * 1e6
+            compout = -1 if compout <= 0 else 1
+            self.dbits[n] = max(0, compout)
+            vdac -= compout * self.vref / 2 * cweights[n] / cdenom
+
+        # Re-scale the data
+        scalar = 2**self.nbits / cdenom
+        self.dval = min(2**self.nbits - 1, scalar * sum(self.weights * self.dbits))