quisk_hardware_sdriq.py

# Please do not change this hardware control module.
# It provides support for the SDR-IQ by RfSpace.

from __future__ import print_function
from __future__ import absolute_import
from __future__ import division

import wx, traceback, types
try:
  import serial
except:
  serial = None
from quisk_hardware_model import Hardware as BaseHardware

DEBUG = 0

if sys.version_info.major > 2:
  Q3StringTypes = str
else:
  Q3StringTypes = (str, unicode)

class Hardware(BaseHardware):
  decimations = [1250, 600, 500, 360]
  def __init__(self, app, conf):
    BaseHardware.__init__(self, app, conf)
    self.rf_gain_labels = ('RF +30', 'RF +20', 'RF +10', 'RF 0 dB')
    if conf.fft_size_multiplier == 0:
      conf.fft_size_multiplier = 3		# Set size needed by VarDecim
    self.clock = int(conf.sdriq_clock)
    self.device = Sdriq(self, conf.sdriq_name, self.clock, conf.sdriq_decimation)	# SDR-IQ hardware access
    self.busy_cursor = False		# Is the busy cursor displayed?
    rx_bytes = 2	# rx_bytes is the number of bytes in each I or Q sample: 1, 2, 3, or 4
    rx_endian = 0	# rx_endian is the order of bytes in the sample array: 0 == little endian; 1 == big endian
    self.InitSamples(rx_bytes, rx_endian)	# Initialize: read samples from this hardware file and send them to Quisk
  def open(self):	# This method must return a string showing whether the open succeeded or failed.
    return self.device.open()
  def close(self):
    self.device.close()
  def OnButtonRfGain(self, event):
    """Set the SDR-IQ preamp gain and attenuator state.

    self.device.SetGain(gstate, gain)
    gstate == 0:  Gain must be 0, -10, -20, or -30
    gstate == 1:  Attenuator is on  and gain is 0 to 127 (7 bits)
    gstate == 2:  Attenuator is off and gain is 0 to 127 (7 bits)
    gain for 34, 24, 14, 4 db is 127, 39, 12, 4.
    """
    btn = event.GetEventObject()
    n = btn.index
    if n == 0:
      self.device.SetGain(2, 127)
    elif n == 1:
      self.device.SetGain(2, 39)
    elif n == 2:
      self.device.SetGain(2, 12)
    elif n == 3:
      self.device.SetGain(1, 12)
    else:
      print ('Unknown RfGain')
  def ChangeFrequency(self, tune, vfo, source='', band='', event=None):
    if vfo:
      self.device.SetFrequency(vfo - self.transverter_offset)
    return tune, vfo
  def ChangeBand(self, band):
    # band is a string: "60", "40", "WWV", etc.
    BaseHardware.ChangeBand(self, band)
    btn = self.application.BtnRfGain
    if btn:
      if band in ('160', '80', '60', '40'):
        btn.SetLabel('RF +10', True)
      elif band in ('20',):
        btn.SetLabel('RF +20', True)
      else:
        btn.SetLabel('RF +20', True)
  def VarDecimGetChoices(self):		# return text labels for the control
    l = []		# a list of sample rates
    for dec in self.decimations:
      l.append(str(int(float(self.clock) / dec / 1e3 + 0.5)))
    return l
  def VarDecimGetLabel(self):		# return a text label for the control
    return "Sample rate ksps"
  def VarDecimGetIndex(self):		# return the current index
    return self.index
  def VarDecimSet(self, index=None):		# set decimation, return sample rate
    if index is None:		# initial call to set decimation before the call to open()
      rate = self.application.vardecim_set		# May be None or from different hardware
      try:
        dec = int(float(self.clock / rate + 0.5))
        self.index = self.decimations.index(dec)
      except:
        try:
          self.index = self.decimations.index(self.conf.sdriq_decimation)
        except:
          self.index = 0
    else:
      self.index = index
    dec = self.decimations[self.index]
    self.device.SetDecimation(dec)
    if index is not None:
      wx.BeginBusyCursor()
      self.busy_cursor = True
    return int(float(self.clock) / dec + 0.5)
  def HeartBeat(self):
    if self.busy_cursor:
      if self.device.sdriq_decimation == self.device.new_decimation:
        wx.EndBusyCursor()
        self.busy_cursor = False
  def StartSamples(self):	# called by the sound thread
    self.device.StartSamples()
  def GetRxSamples(self):	# called by the sound thread
    # Quisk will call this frequently from the sound thread. Call AddRxSamples() to return the samples.
    self.device.GetRxSamples()
  def StopSamples(self):	# called by the sound thread
    self.device.StopSamples()

# This class provides access to the SDR-IQ by RfSpace.
class Sdriq:
  TYPE_HOST_SET = 0x00
  TYPE_HOST_GET = 0x20
  SDRIQ_READ_TIME = 0.004	# Number of seconds to wait for SDR-IQ data on each read
  def __init__(self, hardware, name, clock, decim):
    self.hardware = hardware
    self.sdriq_name = name		# port name such as "/dev/ttyUSB0" or "COM6"
    self.sdriq_clock = clock
    self.sdriq_decimation = decim	# currently programmed decimation
    self.new_decimation = decim		# new requested decimation
    self.sdriq_idle = -1
    self.port = None
    self.sdriq_gstate = self.new_gstate = 2
    self.sdriq_gain = self.new_gain = 127
    self.sdriq_freq = self.new_freq = 7220000
  def open(self):
    self.sdr_name = ''			# name as reported by the hardware
    self.sdr_serial = ''		# serial number as reported by the hardware
    self.sdr_data = bytearray(0)	# the data block sent by the SDR-IQ
    self.sdr_state = 0
    if not serial:
      self.port = None
      return 'SDR-IQ requires the missing Python "serial" module'
    try:
      self.port = serial.Serial(self.sdriq_name, baudrate=230400, timeout=self.SDRIQ_READ_TIME)
    except:
      if DEBUG:
        traceback.print_exc()
      self.port = None
      return "Can not open SDR-IQ port name %s" % self.sdriq_name
    self.SetItem(0x0018, b"\x81\x01\x00\x00")
    self.port.reset_input_buffer()
    self.port.reset_output_buffer()
    self.SetItem(0x0018, b"\x81\x01\x00\x00")
    self.GetItem(0x0002, b'')		# request serial number
    self.GetItem(0x0005, b'')		# request status
    self.GetItem(0x0001, b'')		# request name
    for i in range(50):
      self.ReadSdriq()	# read the port for data from the GUI thread
      if self.sdr_name:
        break
    else:
      self.port.close()
      self.port = None
      return "No response from SDR-IQ"
    # set the clock speed
    freq = self.sdriq_clock
    data = bytearray(5)
    data[0] = 0
    data[1] = freq & 0xFF
    freq = freq >> 8
    data[2] = freq & 0xFF
    freq = freq >> 8
    data[3] = freq & 0xFF
    freq = freq >> 8
    data[4] = freq & 0xFF
    self.SetItem(0x00B0, data)
    t = "Capture from %s serial %s" % (self.sdr_name, self.sdr_serial)
    if DEBUG: print("Open device:", t)
    self.ProgramAD6620()
    return t
  def close(self):
    if self.port:
      self.port.close()
    self.port = None
  def StartSamples(self):
    if self.sdriq_idle != 2 and self.port:
      buf = bytearray(4)
      buf[0] = 0x81
      buf[1] = 0x02
      buf[2] = 0x00
      buf[3] = 0x01
      self.SetItem(0x0018, buf)
      if DEBUG: print ("StartSamples")
  def StopSamples(self):
    if not self.port:
      return
    if DEBUG: print ("StopSamples")
    buf = bytearray(4)
    buf[0] = 0x81
    buf[1] = 0x01
    buf[2] = 0x00
    buf[3] = 0x00
    for i in range(10):
      self.SetItem(0x0018, buf)
      self.ReadSdriq()
      if self.sdriq_idle == 1:
        if DEBUG: print ("StopSamples at index", i)
        break
  def SetDecimation(self, decim):
    self.new_decimation = decim	
  def SetFrequency(self, freq):
    self.new_freq = freq
  def SetGain(self, gstate, gain):
    self.new_gstate = gstate
    self.new_gain = gain
  def GetItem(self, item, params):
    length = 4 + len(params)
    data = bytearray(4)
    data[0] = length & 0xFF		# length LSB
    data[1] = self.TYPE_HOST_GET | ((length >> 8) & 0x1F)	# 3-bit type and 5-bit length MSB
    data[2] = item & 0xFF		# item LSB
    data[3] = (item >> 8) & 0xFF	# item MSB
    data = data + params
    if self.port.write(data) != length:
      self.hardware.GotReadError(DEBUG, "SDR-IQ GetItem write error")
  def SetItem(self, item, params):
    length = 4 + len(params)
    data = bytearray(4)
    data[0] = length & 0xFF				# length LSB
    data[1] = self.TYPE_HOST_SET | ((length >> 8) & 0x1F)	# 3-bit type and 5-bit length MSB
    data[2] = item & 0xFF			# item LSB
    data[3] = (item >> 8) & 0xFF	# item MSB
    data = data + params
    if self.port.write(data) != length:
      self.hardware.GotReadError(DEBUG, "SDR-IQ SetItem write error")
  def ProgramFrequency(self):
    freq = self.sdriq_freq
    buf = bytearray(6)
    buf[0] = 0
    buf[1] = freq & 0xFF
    freq = freq >> 8
    buf[2] = freq & 0xFF
    freq = freq >> 8
    buf[3] = freq & 0xFF
    freq = freq >> 8
    buf[4] = freq & 0xFF
    buf[5] = 1
    self.SetItem(0x0020, buf)
  def ProgramGain(self):
    gain = self.sdriq_gain
    gstate = self.sdriq_gstate
    buf = bytearray(2)
    if gstate == 0:
      buf[0] = 0
      buf[1] = gain & 0xFF
    elif gstate == 1:
      buf[0] = 1
      buf[1] = gain & 0x7F
      buf[1] |= 0x80
    else:
      buf[0] = 1
      buf[1] = gain & 0x7F
    self.SetItem(0x0038, buf)
  def GetRxSamples(self):	# Check for changes in decimation, frequency or gain.
    if not self.port:		# Poll the device for samples.
      return None
    if self.sdriq_decimation != self.new_decimation:
      if DEBUG: print ("Set decimation to", self.new_decimation, "currently", self.sdriq_decimation)
      self.StopSamples()
      self.ProgramAD6620()
      self.StartSamples()
      self.sdriq_decimation = self.new_decimation
    if self.sdriq_freq != self.new_freq:
      self.sdriq_freq = self.new_freq
      self.ProgramFrequency()
    if self.sdriq_gain != self.new_gain or self.sdriq_gstate != self.new_gstate:
      self.sdriq_gain = self.new_gain
      self.sdriq_gstate = self.new_gstate
      self.ProgramGain()
    self.ReadSdriq()
  def ReadSdriq(self):	# Read all data from the SDR-IQ and process it.
    # The ft245 driver does not have a circular buffer for input; bytes are just appended
    # to the buffer.  When all bytes are read and the buffer goes empty, the pointers are reset to zero.
    # Be sure to empty out the ft245 frequently so its buffer does not overflow.
    if not self.port:
      return
    data = self.port.read(8192)		# this is a blocking read for SDRIQ_READ_TIME seconds
    if isinstance(data, Q3StringTypes):
      data = bytearray(data)
    index = 0
    length = len(data)
    while index < length:
      if self.sdr_state == 0:		# read the first byte
        del self.sdr_data[:]
        byte = data[index]
        index += 1
        self.sdr_length = byte
        self.sdr_state = 1
      elif self.sdr_state == 1:		# read the second byte
        byte = data[index]
        index += 1
        self.sdr_type = (byte >> 5) & 0x7		# 3-bit type
        self.sdr_length |= (byte & 0x1F) << 8		# length including header
        if self.sdr_length == 0:
          if self.sdr_type > 3:		# special length
            self.sdr_length = 8194
          else:				# NAK
            self.sdr_nak = 1
            self.sdr_state = 0
            continue
        self.sdr_length -= 2
        if self.sdr_length <= 0 or (self.sdr_length > 50 and self.sdr_length < 8192):	# out of sync
          self.hardware.GotReadError(DEBUG, "SDR-IQ lost sync: type %d  length %d" % (self.sdr_type, self.sdr_length))
          self.sdr_state = 9
        else:
          self.sdr_state = 2
      elif self.sdr_state == 2:		# read all the "sdr_length" bytes
        index2 = index + self.sdr_length - len(self.sdr_data)
        self.sdr_data += data[index:index2]
        index = index2
        if len(self.sdr_data) >= self.sdr_length:	# we have all the data for this record
          self.sdr_state = 0
          if DEBUG > 1:
            print("Got data type %d length %d" % (self.sdr_type, self.sdr_length))
          if self.sdr_length == 1 and self.sdr_type == 3:	# ACK
            self.sdr_ack = self.sdr_data[0]
          elif self.sdr_type < 2 and self.sdr_length >= 2:	# control item
            item = self.sdr_data[0] | self.sdr_data[1] << 8
            if item == 1:
              self.sdr_name = self.sdr_data[2:-1].decode('utf-8')
            elif item == 2:
              self.sdr_serial = self.sdr_data[2:-1].decode('utf-8')
            elif item == 3:
              self.sdr_interface = self.sdr_data[3] << 8 | self.sdr_data[2]
            elif item == 4:
              if self.sdr_data[2]:
                self.sdr_firmware = self.sdr_data[4] << 8 | self.sdr_data[3]
              else:
                self.sdr_bootcode = self.sdr_data[4] << 8 | self.sdr_data[3]
            elif item == 5:
              self.sdr_status = self.sdr_data[2]
              if self.sdr_status == 0x20:
                self.hardware.GotClip()
            elif item == 0x18:
              self.sdriq_idle = self.sdr_data[3]
              if (DEBUG): print("sdriq_idle", self.sdriq_idle)
          elif self.sdr_type == 4 and self.sdr_length == 8192:	# ADC sample block
            self.hardware.AddRxSamples(self.sdr_data)
      elif self.sdr_state == 9:		# out of sync; try to re-synchronize
        # look for the start of data blocks "\x00\x80"
        byte = data[index]
        index += 1
        if byte == 0x00:
          self.sdr_state = 10
      elif self.sdr_state == 10:
        byte = data[index]
        index += 1
        if byte == 0x80:
          del self.sdr_data[:]
          self.sdr_length = 8192
          self.sdr_state = 2
        elif byte != 0x00:
          self.sdr_state = 9
  def SetAD6620(self, address, value):		# set an AD6620 register
    buf = bytearray(9)
    buf[0] = 0x09
    buf[1] = 0xA0
    buf[2] = address & 0xFF
    buf[3] = (address >> 8) & 0xFF
    buf[4] = value & 0xFF
    value = value >> 8
    buf[5] = value & 0xFF
    value = value >> 8
    buf[6] = value & 0xFF
    value = value >> 8
    buf[7] = value & 0xFF
    buf[8] = 0
    if self.port.write(buf) != len(buf):
      self.hardware.GotReadError(DEBUG, "SDR-IQ SetAD6620 write error")
  def WsetAD6620(self, address, value):		# set an AD6620 register and wait for the ACK
    self.sdr_ack = -1
    self.SetAD6620(address, value)
    for i in range(50):
      self.ReadSdriq()
      if self.sdr_ack != -1:
        break
    if self.sdr_ack != 1:
      self.hardware.GotReadError(DEBUG, "SDR-IQ failed to get ACK for AD6620 address 0x%X" % address)
  def ProgramAD6620(self):
    decim = self.new_decimation
    if decim == 360:
      scale = (4, 18, 5, 4, 13, 6)
      coef = (
131, -230, -38, -304, -235, -346, -237, -181, 12, 149, 310, 349, 320, 154, -60,
-310, -480, -540, -423, -169, 187, 523, 749, 762, 543, 117, -394, -851, -1093, -1025,
-621, 22, 737, 1300, 1522, 1288, 625, -309, -1245, -1893, -2013, -1515, -489, 793, 1957,
 2623, 2533, 1640, 149, -1533, -2893, -3475, -3023, -1584, 480, 2582, 4063, 4405, 3401, 1246,
-1484, -3986, -5455, -5345, -3557, -509, 2951, 5776, 7030, 6193, 3355, -760, -4970, -7969, -8722,
-6815, -2628, 2712, 7632, 10563, 10431, 7033, 1169, -5529, -11037, -13543, -12021, -6623, 1287, 9443,
 15320, 16896, 13319, 5269, -5122, -14811, -20711, -20642, -14088, -2504, 10961, 22272, 27682, 24909, 13986,
-2524, -20051, -33214, -37378, -30153, -12380, 11742, 35506, 51387, 53179, 38008, 7662, -31208, -68176, -91255,
-89756, -57102, 7096, 96306, 197916, 295555, 372388, 414662, 414662, 372388, 295555, 197916, 96306, 7096, -57102,
-89756, -91255, -68176, -31208, 7662, 38008, 53179, 51387, 35506, 11742, -12380, -30153, -37378, -33214, -20051,
-2524, 13986, 24909, 27682, 22272, 10961, -2504, -14088, -20642, -20711, -14811, -5122, 5269, 13319, 16896,
 15320, 9443, 1287, -6623, -12021, -13543, -11037, -5529, 1169, 7033, 10431, 10563, 7632, 2712, -2628,
-6815, -8722, -7969, -4970, -760, 3355, 6193, 7030, 5776, 2951, -509, -3557, -5345, -5455, -3986,
-1484, 1246, 3401, 4405, 4063, 2582, 480, -1584, -3023, -3475, -2893, -1533, 149, 1640, 2533,
 2623, 1957, 793, -489, -1515, -2013, -1893, -1245, -309, 625, 1288, 1522, 1300, 737, 22,
-621, -1025, -1093, -851, -394, 117, 543, 762, 749, 523, 187, -169, -423, -540, -480,
-310, -60, 154, 320, 349, 310, 149, 12, -181, -237, -346, -235, -304, -38, -230, 131)
    elif decim == 500:
      scale = (4, 25, 5, 4, 16, 5)
      coef = (
-197, 356, -153, 176, -101, 34, -125, -46, -106, -7, 12, 115, 129,
 157, 86, 12, -116, -197, -251, -203, -97, 80, 242, 364, 367,
 259, 33, -228, -461, -565, -504, -255, 106, 488, 756, 813, 604,
 172, -377, -868, -1139, -1066, -639, 53, 807, 1390, 1584, 1288, 537,
-470, -1439, -2046, -2060, -1406, -232, 1143, 2290, 2820, 2496, 1339, -366,
-2120, -3369, -3659, -2808, -976, 1340, 3448, 4652, 4486, 2873, 198, -2785,
-5152, -6095, -5184, -2546, 1137, 4785, 7240, 7613, 5604, 1641, -3190, -7438,
-9701, -9091, -5546, 69, 6163, 10849, 12519, 10373, 4745, -2905, -10342, -15198,
-15692, -11253, -2807, 7368, 16229, 20838, 19296, 11436, -946, -14436, -24891, -28637,
-23657, -10406, 8025, 26518, 39215, 41181, 30008, 6896, -23122, -51997, -70364, -69788,
-44995, 4465, 73600, 152608, 228689, 288639, 321648, 321648, 288639, 228689, 152608, 73600,
 4465, -44995, -69788, -70364, -51997, -23122, 6896, 30008, 41181, 39215, 26518, 8025,
-10406, -23657, -28637, -24891, -14436, -946, 11436, 19296, 20838, 16229, 7368, -2807,
-11253, -15692, -15198, -10342, -2905, 4745, 10373, 12519, 10849, 6163, 69, -5546,
-9091, -9701, -7438, -3190, 1641, 5604, 7613, 7240, 4785, 1137, -2546, -5184,
-6095, -5152, -2785, 198, 2873, 4486, 4652, 3448, 1340, -976, -2808, -3659,
-3369, -2120, -366, 1339, 2496, 2820, 2290, 1143, -232, -1406, -2060, -2046,
-1439, -470, 537, 1288, 1584, 1390, 807, 53, -639, -1066, -1139, -868,
-377, 172, 604, 813, 756, 488, 106, -255, -504, -565, -461, -228,
 33, 259, 367, 364, 242, 80, -97, -203, -251, -197, -116, 12,
 86, 157, 129, 115, 12, -7, -106, -46, -125, 34, -101, 176, -153, 356, -197)
    elif decim == 600:
      scale = (5, 30, 4, 5, 17, 5)
      coef = (
 436, -1759, 99, -1281, 0, -280, 619, 409, 553, -71, -344, -753, -537, -203,
 453, 782, 838, 325, -326, -949, -1037, -628, 230, 991, 1330, 923, 10, -1032,
-1569, -1324, -299, 956, 1822, 1739, 716, -809, -2000, -2212, -1212, 520, 2123, 2678,
 1823, -111, -2124, -3143, -2509, -463, 2002, 3548, 3279, 1188, -1699, -3877, -4088,
-2087, 1206, 4069, 4920, 3137, -478, -4094, -5720, -4343, -493, 3887, 6454, 5669, 1741,
-3412, -7052, -7096, -3266, 2607, 7462, 8573, 5084, -1425, -7602, -10058, -7187, -193,
 7400, 11481, 9579, 2301, -6756, -12777, -12244, -4971, 5569, 13854, 15181, 8285, -3699,
-14613, -18387, -12369, 966, 14920, 21888, 17412, 2905, -14598, -25744, -23754, -8362,
 13363, 30114, 32035, 16259, -10708, -35362, -43638, -28445, 5493, 42387, 62053, 49891, 5603, -53825,
-99044, -99811, -38467, 80479, 229234, 365232, 446270, 446270, 365232, 229234, 80479, -38467,
-99811, -99044, -53825, 5603, 49891, 62053, 42387, 5493, -28445, -43638, -35362, -10708, 16259,
 32035, 30114, 13363, -8362, -23754, -25744, -14598, 2905, 17412, 21888, 14920, 966, -12369,
-18387, -14613, -3699, 8285, 15181, 13854, 5569, -4971, -12244, -12777, -6756, 2301, 9579,
 11481, 7400, -193, -7187, -10058, -7602, -1425, 5084, 8573, 7462, 2607, -3266, -7096, -7052, -3412,
 1741, 5669, 6454, 3887, -493, -4343, -5720, -4094, -478, 3137, 4920, 4069, 1206, -2087, -4088,
-3877, -1699, 1188, 3279, 3548, 2002, -463, -2509, -3143, -2124, -111, 1823, 2678, 2123, 520, -1212,
-2212, -2000, -809, 716, 1739, 1822, 956, -299, -1324, -1569, -1032, 10, 923, 1330, 991, 230, -628,
-1037, -949, -326, 325, 838, 782, 453, -203, -537, -753, -344, -71, 553, 409, 619, -280, 0, -1281,
 99, -1759, 436)
    else:	# decim == 1250
      scale = (10, 25, 5, 7, 15, 6)
      coef = (
-378, 13756, -14444, 8014, -7852, 3556, -3779, 2733, -909, 2861, 208, 1827, -755, -243, -2134, -1267, -1705,
 20, 492, 2034, 1885, 1993, 535, -459, -2052, -2387, -2454, -1112, 246, 2053, 2832, 3019, 1774, 133, -1973,
-3220, -3654, -2546, -683, 1769, 3531, 4330, 3431, 1417, -1400, -3730, -5013, -4428, -2350, 831, 3780, 5669,
 5520, 3489, -23, -3635, -6252, -6689, -4839, -1057, 3245, 6715, 7904, 6403, 2443, -2555, -6998, -9129, -8175,
-4172, 1504, 7033, 10318, 10147, 6281, -23, -6747, -11415, -12315, -8815, -1972, 6041, 12354, 14669, 11830, 4593,
-4800, -13060, -17207, -15419, -7992, 2861, 13425, 19944, 19729, 12404, 21, -13318, -22930, -25017, -18239, -4245,
 12519, 26289, 31789, 26259, 10571, -10635, -30306, -41114, -38121, -20661, 6795, 35686, 55688, 58124, 39093, 1561,
-44548, -84372, -101901, -84500, -26969, 66196, 180937, 296484, 390044, 442339, 442339, 390044, 296484, 180937,
 66196, -26969, -84500, -101901, -84372, -44548, 1561, 39093, 58124, 55688, 35686, 6795, -20661, -38121, -41114,
-30306, -10635, 10571, 26259, 31789, 26289, 12519, -4245, -18239, -25017, -22930, -13318, 21, 12404, 19729, 19944,
 13425, 2861, -7992, -15419, -17207, -13060, -4800, 4593, 11830, 14669, 12354, 6041, -1972, -8815, -12315, -11415,
-6747, -23, 6281, 10147, 10318, 7033, 1504, -4172, -8175, -9129, -6998, -2555, 2443, 6403, 7904, 6715, 3245, -1057,
-4839, -6689, -6252, -3635, -23, 3489, 5520, 5669, 3780, 831, -2350, -4428, -5013, -3730, -1400, 1417, 3431, 4330,
 3531, 1769, -683, -2546, -3654, -3220, -1973, 133, 1774, 3019, 2832, 2053, 246, -1112, -2454, -2387, -2052, -459,
 535, 1993, 1885, 2034, 492, 20, -1705, -1267, -2134, -243, -755, 1827, 208, 2861, -909, 2733, -3779, 3556, -7852,
 8014, -14444, 13756, -378 )
    self.WsetAD6620(0x300, 1)
    for i in range(256):
      self.WsetAD6620(i, coef[i])
    self.WsetAD6620(0x301, 0)
    self.WsetAD6620(0x302, -1)
    self.WsetAD6620(0x303, 0)
    self.WsetAD6620(0x304, 0)
    self.WsetAD6620(0x305, scale[3])
    self.WsetAD6620(0x306, scale[0] - 1)
    self.WsetAD6620(0x307, scale[4])
    self.WsetAD6620(0x308, scale[1] - 1)
    self.WsetAD6620(0x309, scale[5])
    self.WsetAD6620(0x30A, scale[2] - 1)
    self.WsetAD6620(0x30B, 0)
    self.WsetAD6620(0x30C, 255)
    self.WsetAD6620(0x30D, 0)
    self.ProgramFrequency()
    self.ProgramGain()
    self.WsetAD6620(0x300, 0)