initial commit

JDS6600.py

@@ -0,0 +1,100 @@
+import serial.tools.list_ports
+import serial
+
+# https://joy-it.net/files/files/Produkte/JT-JD6600/JT-JDS6600-Communication-protocol.pdf
+
+DEBUG = False
+
+def list_com_ports():
+    if len(serial.tools.list_ports.comports()) > 0:
+        for port in serial.tools.list_ports.comports():
+            print("{}".format(port))
+    else:
+        raise Exception("No serial port detected.")
+
+        
+def connect(port):
+    return serial.Serial(
+        port=port, baudrate=115200, bytesize=8, timeout=2, stopbits=serial.STOPBITS_ONE
+    )
+
+SINE = 0
+SQUARE = 1
+PULSE = 2
+TRIANGULAR = 3
+    
+def set_waveform(serialPort, channel, wave):
+    if channel == 1:
+        cmd = b'w21'
+    else:
+        cmd = b'w22'
+    # :w21=0.\r\n  sine wave channel 1
+    line = b':' + cmd + b'=' + str(wave).encode() + b'.\r\n'
+    if DEBUG:
+        print("Sending: {}".format(line))
+    serialPort.write(line)
+    
+    res = serialPort.readline()
+    if res != b':ok\r\n':
+        raise Exception("Can't set waveform {}".format(res))
+
+# frequency in Hz 
+def set_frequency(serialPort, channel, frequency):
+    if channel == 1:
+        cmd = b'w23'
+    else:
+        cmd = b'w24'
+    # :w23=500000,0.\r\n 5KHz channel 1
+    line = b':' + cmd + b'=' + str(frequency*100).encode() + b',0.\r\n'
+    if DEBUG:
+        print("Sending: {}".format(line))
+    serialPort.write(line)
+    
+    res = serialPort.readline()
+    if res != b':ok\r\n':
+        raise Exception("Can't set frequency {}".format(res))
+
+# amplitude in V
+def set_amplitude(serialPort, channel, amplitude):
+    if channel == 1:
+        cmd = b'w25'
+    else:
+        cmd = b'w26'
+    # :w25=1000.\r\n 1Vpp channel 1
+    line = b':' + cmd + b'=' + str(amplitude*1000).encode() + b'.\r\n'
+    if DEBUG:
+        print("Sending: {}".format(line))
+    serialPort.write(line)
+    
+    res = serialPort.readline()
+    if res != b':ok\r\n':
+        raise Exception("Can't set amplitude {}".format(res))
+
+# offset in V
+# TODO not sure about the calculation!
+def set_offset(serialPort, channel, offset):
+    if channel == 1:
+        cmd = b'w27'
+    else:
+        cmd = b'w28'
+    # :w27=1000.\r\n 0Vpp channel 1
+    line = b':' + cmd + b'=' + str(offset*100+1000).encode() + b'.\r\n'
+    if DEBUG:
+        print("Sending: {}".format(line))
+    serialPort.write(line)
+    
+    res = serialPort.readline()
+    if res != b':ok\r\n':
+        raise Exception("Can't set amplitude {}".format(res))
+
+def set_output(serialPort, channel1=0, channel2=0):
+    line = b':w20=' + str(channel1).encode() + b',' + str(channel2).encode() + b'r\n'
+    if DEBUG:
+        print("Sending: {}".format(line))
+    serialPort.write(line)
+    
+    res = serialPort.readline()
+    if res != b':ok\r\n':
+        raise Exception("Can't set output state {}".format(res))
+    
+   

README.md

@@ -0,0 +1,17 @@
+# Bode plot
+
+This python notebook allows to analyse the frequency response and trace the bode plot of a device (guitar pedal, filter, ...)
+
+The script connects to the a Siglent osccilloscope and a JDS6600 via NI-VISA or serial and issue SCPI commands.
+
+![schematic](doc/schematic.jpg)
+
+Klone with tone at the minimum
+
+![min](doc/klonetonemin.png)
+
+
+Klone with tone at the maximum
+
+![min](doc/klonetonemax.png)
+

SDS1202XE.py

@@ -0,0 +1,101 @@
+import pyvisa
+import os
+import re
+from PIL import Image as PILImage
+from IPython.display import Image
+from retry import retry
+
+DEBUG = True
+
+# https://siglentna.com/wp-content/uploads/dlm_uploads/2017/10/ProgrammingGuide_forSDS-1-1.pdf
+
+def get_resource_manager():
+    return pyvisa.ResourceManager()
+
+def list_resources(rm):
+    l = rm.list_resources()
+    if len(l) > 0:
+        print(l)
+    else:
+        raise Exception("No VISA device detected.")
+
+def connect(rm, resource):
+    sds = rm.open_resource(resource)
+    print(sds.query("*IDN?"))
+    
+    return sds
+    
+
+IMG_PATH = "./img"
+    
+def screenshot(sds, name):
+    bmpfile = os.path.join(IMG_PATH, name + ".bmp")
+    pngfile = os.path.join(IMG_PATH, name + ".png")
+    
+    sds.write("SCDP")
+    res = sds.read_raw()
+    with open(bmpfile, 'wb') as f:
+        f.write(res)
+
+    # convert to png
+    PILImage.open(bmpfile).save(pngfile)
+    os.remove(bmpfile)    
+    
+    return Image(filename=pngfile) 
+
+#def get_frequency(sds):
+#    res = sds.query("CYMOMETER?")
+#    print("{}".format(res))
+
+def get_vertical(sds, channel):    
+    cmd = "C{}:Volt_DIV?".format(channel)
+    res = sds.query(cmd)
+    print("{}".format(res))
+
+def set_vertical(sds, channel, volt_by_div):
+    cmd = "C{}:VDIV {}".format(channel, volt_by_div)
+    sds.write(cmd)
+
+def get_tdiv(sds):
+    print(sds.query("TDIV?"))
+
+def set_tdiv(sds, tdiv):
+    cmd = "TDIV {}".format(tdiv)
+    sds.write(cmd)
+
+def autosetup(sds):
+    sds.write("ASET")
+
+def set_phase_measure(sds):
+    sds.write("MEAD PHA,C1-C2")
+
+@retry(Exception)
+def get_phase(sds):
+    res = sds.query("C1-C2:MEAD? PHA")
+    # C1-C2:MEAD PHA,-75.72degree
+    match = re.search(r"PHA,(.*?)degree", res)
+    if match:
+        return float(match.group(1))
+    else:
+        raise Exception("Can't read the phase in {}".format(res))
+
+def set_measure(sds, channel):
+    sds.write("PACU PKPK,C{}".format(channel))
+    sds.write("PACU FREQ,C{}".format(channel))
+
+@retry(Exception)
+def get_measure_vpp(sds, channel):
+    res = sds.query("C{}:PAVA? PKPK".format(channel))
+    # C1:PAVA PKPK,9.04E+00V
+    match = re.search(r"PKPK,(.*?)V", res)
+    if match:
+        return float(match.group(1))
+    else:
+        raise Exception("Can't read Peak to Peak value in {}".format(res))
+
+@retry(Exception)
+def get_measure_freq(sds, channel):
+    res = sds.query("C{}:PAVA? FREQ".format(channel))
+    print("{}".format(res))
+    
+    

bode.ipynb

@@ -0,0 +1,171 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fundamental-insertion",
+   "metadata": {},
+   "source": [
+    "# Bode plot"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "balanced-pocket",
+   "metadata": {},
+   "source": [
+    "## List connected devices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "limiting-gardening",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import JDS6600\n",
+    "import SDS1202XE\n",
+    "from bodeplot import bodeplot\n",
+    "import time\n",
+    "import math\n",
+    "\n",
+    "rm = SDS1202XE.get_resource_manager()\n",
+    "SDS1202XE.list_resources(rm)\n",
+    "JDS6600.list_com_ports()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fuzzy-closure",
+   "metadata": {},
+   "source": [
+    "## Connect devices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "judicial-invite",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gen = JDS6600.connect(\"COM5\")\n",
+    "sds = SDS1202XE.connect(rm, \"USB0::0xF4ED::0xEE3A::SDS1EDEQ4R7911::INSTR\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "thorough-speech",
+   "metadata": {},
+   "source": [
+    "## Initialize"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "reduced-collection",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MAXV = 2\n",
+    "\n",
+    "JDS6600.set_waveform(gen, 1, JDS6600.SINE)\n",
+    "JDS6600.set_frequency(gen, 1, 10)\n",
+    "JDS6600.set_amplitude(gen, 1, MAXV)\n",
+    "JDS6600.set_offset(gen, 1, 0)\n",
+    "JDS6600.set_output(gen, channel1=1, channel2=0)\n",
+    "\n",
+    "time.sleep(1)\n",
+    "#SDS1202XE.autosetup(sds)\n",
+    "#time.sleep(3)\n",
+    "SDS1202XE.set_vertical(sds, channel=1, volt_by_div = \"1V\")\n",
+    "SDS1202XE.set_vertical(sds, channel=2, volt_by_div = \"500mV\")\n",
+    "SDS1202XE.set_tdiv(sds, tdiv=\"20MS\")\n",
+    "SDS1202XE.set_measure(sds, channel=1)\n",
+    "SDS1202XE.set_phase_measure(sds)\n",
+    "time.sleep(1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "atomic-california",
+   "metadata": {},
+   "source": [
+    "## Launch measures"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "classified-mineral",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "frequencies = [10, 20, 50, 100, 200, 500, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 11000, 12000, 13000, 14000, 15000, 16000, 18000, 20000, 22000]\n",
+    "\n",
+    "gains = []\n",
+    "phases = []\n",
+    "\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "for i in tqdm(range(len(frequencies))):\n",
+    "    f = frequencies[i]\n",
+    "    JDS6600.set_frequency(gen, 1, f)\n",
+    "    time.sleep(1.0)\n",
+    "    v = SDS1202XE.get_measure_vpp(sds, channel=1)\n",
+    "    p = SDS1202XE.get_phase(sds)\n",
+    "    gains.append(10*math.log(v/MAXV, 10))\n",
+    "    phases.append(p)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dated-sample",
+   "metadata": {},
+   "source": [
+    "## Bode plot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "parental-strap",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bodeplot(frequencies, gains, phases)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "guilty-accent",
+   "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
+}

bodeplot.py

@@ -0,0 +1,36 @@
+
+import matplotlib.pyplot as plt
+from scipy import interpolate
+from si_prefix import si_format
+import numpy as np
+
+def bodeplot(f, g, p):
+
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 6))
+    fig.subplots_adjust(hspace=0.5)
+        
+    ax1.set_title("Bode plot")
+
+    ax1.set_ylabel('gain (dB)')
+    ax1.set_xlabel('f (Hz)')
+    ax1.grid(True)
+    ax1.semilogx(f, g, 'C2')
+    ax1.axhline(y=-3.0)
+
+    try:
+        # find fc at -3db
+        yreduced = np.array(g) - (-3.0)
+        freduced = interpolate.UnivariateSpline(f, yreduced, s=0)
+        fc = freduced.roots()[0]
+
+        ax1.scatter([fc], [-3.0], c = 'red')
+        ax1.annotate("fc=" + si_format(fc, precision=2) + "Hz", xy= (fc, -3.0), xytext=(fc, -2.5) )
+    except:
+        print("Warning: can't find fc")
+    
+    ax2.set_ylabel('phase (°)')
+    ax2.set_xlabel('f (Hz)')
+    ax2.semilogx(f, p, 'C2')
+    ax2.grid(True)
+
+    return plt.show()

requirements.txt

@@ -0,0 +1,7 @@
+pyvisa
+pyserial
+Pyllow
+matplotlib
+tdqm
+scipy
+si-prefix

retry.py

@@ -0,0 +1,46 @@
+import time
+from functools import wraps
+
+# https://www.saltycrane.com/blog/2009/11/trying-out-retry-decorator-python/
+def retry(ExceptionToCheck, tries=2, delay=1, backoff=1, logger=None):
+    """
+    Retry calling the decorated function using an exponential backoff.
+
+    http://www.saltycrane.com/blog/2009/11/trying-out-retry-decorator-python/
+    original from: http://wiki.python.org/moin/PythonDecoratorLibrary#Retry
+
+    :param ExceptionToCheck: the exception to check. may be a tuple of
+        exceptions to check
+    :type ExceptionToCheck: Exception or tuple
+    :param tries: number of times to try (not retry) before giving up
+    :type tries: int
+    :param delay: initial delay between retries in seconds
+    :type delay: int
+    :param backoff: backoff multiplier e.g. value of 2 will double the delay
+        each retry
+    :type backoff: int
+    :param logger: logger to use. If None, print
+    :type logger: logging.Logger instance
+    """
+    def deco_retry(f):
+
+        @wraps(f)
+        def f_retry(*args, **kwargs):
+            mtries, mdelay = tries, delay
+            while mtries > 1:
+                try:
+                    return f(*args, **kwargs)
+                except ExceptionToCheck as e:
+                    msg = "%s, Retrying in %d seconds..." % (str(e), mdelay)
+                    if logger:
+                        logger.warning(msg)
+                    else:
+                        print(msg)
+                    time.sleep(mdelay)
+                    mtries -= 1
+                    mdelay *= backoff
+            return f(*args, **kwargs)
+
+        return f_retry  # true decorator
+
+    return deco_retry