'''

obj = ScienceLab(**kwargs)

if obj.H.fd is not None:

return obj

else:

print('Err')

"""

CAP_AND_PCS = 0

ADC_SHIFTS_LOCATION1 = 1

ADC_SHIFTS_LOCATION2 = 2

ADC_POLYNOMIALS_LOCATION = 3

# DAC_POLYNOMIALS_LOCATION=1

DAC_SHIFTS_PV1A = 4

DAC_SHIFTS_PV1B = 5

DAC_SHIFTS_PV2A = 6

DAC_SHIFTS_PV2B = 7

DAC_SHIFTS_PV3A = 8

DAC_SHIFTS_PV3B = 9

LOC_DICT = {'PV1': [4, 5], 'PV2': [6, 7], 'PV3': [8, 9]}

BAUD = 1000000

WType = {'W1': 'sine', 'W2': 'sine'}

def __init__(self, timeout=1.0, **kwargs):

self.verbose = kwargs.get('verbose', False)

self.initialArgs = kwargs

self.generic_name = 'PSLab'

self.DDS_CLOCK = 0

self.timebase = 40

self.MAX_SAMPLES = CP.MAX_SAMPLES

self.samples = self.MAX_SAMPLES

self.triggerLevel = 550

self.triggerChannel = 0

self.error_count = 0

self.channels_in_buffer = 0

self.digital_channels_in_buffer = 0

self.currents = [0.55e-3, 0.55e-6, 0.55e-5, 0.55e-4]

self.currentScalers = [1.0, 1.0, 1.0, 1.0]

self.data_splitting = kwargs.get('data_splitting', CP.DATA_SPLITTING)

self.allAnalogChannels = allAnalogChannels

self.analogInputSources = {}

for a in allAnalogChannels: self.analogInputSources[a] = analogInputSource(a)

self.sine1freq = None

self.sine2freq = None

self.sqrfreq = {'SQR1': None, 'SQR2': None, 'SQR3': None, 'SQR4': None}

self.aboutArray = []

self.errmsg = ''

# --------------------------Initialize communication handler, and subclasses-----------------

try:

self.H = packet_handler.Handler(**kwargs)

except Exception as ex:

self.errmsg = "failed to Connect. Please check connections/arguments\n" + ex.message

self.connected = False

print(self.errmsg) # raise RuntimeError(msg)

try:

self.__runInitSequence__(**kwargs)

except Exception as ex:

self.errmsg = "failed to run init sequence. Check device connections\n" + str(ex)

self.connected = False

print(self.errmsg) # raise RuntimeError(msg)

def __runInitSequence__(self, **kwargs):

self.aboutArray = []

from PSL.Peripherals import I2C, SPI, NRF24L01, MCP4728

self.connected = self.H.connected

if not self.H.connected:

self.__print__('Check hardware connections. Not connected')

self.streaming = False

self.achans = [analogAcquisitionChannel(a) for a in ['CH1', 'CH2', 'CH3', 'MIC']]

self.gain_values = gains

self.buff = np.zeros(10000)

self.SOCKET_CAPACITANCE = 42e-12 # 42e-12 is typical for the FOSSASIA PSLab. Actual values will be updated during calibration loading

self.resistanceScaling = 1.

self.digital_channel_names = digital_channel_names

self.allDigitalChannels = self.digital_channel_names

self.gains = {'CH1': 0, 'CH2': 0}

# This array of four instances of digital_channel is used to store data retrieved from the

# logic analyzer section of the device. It also contains methods to generate plottable data

# from the original timestamp arrays.

self.dchans = [digital_channel(a) for a in range(4)]

self.I2C = I2C(self.H)

# self.I2C.pullSCLLow(5000)

self.SPI = SPI(self.H)

self.hexid = ''

if self.H.connected:

for a in ['CH1', 'CH2']: self.set_gain(a, 0, True) # Force load gain

for a in ['W1', 'W2']: self.load_equation(a, 'sine')

self.SPI.set_parameters(1, 7, 1, 0)

self.hexid = hex(self.device_id())

self.NRF = NRF24L01(self.H)

self.aboutArray.append(['Radio Transceiver is :', 'Installed' if self.NRF.ready else 'Not Installed'])

self.DAC = MCP4728(self.H, 3.3, 0)

self.calibrated = False

# -------Check for calibration data if connected. And process them if found---------------

if kwargs.get('load_calibration', True) and self.H.connected:

import struct

# Load constants for CTMU and PCS

cap_and_pcs = self.read_bulk_flash(self.CAP_AND_PCS, 8 * 4 + 5) # READY+calibration_string

if cap_and_pcs[:5] == 'READY':

scalers = list(struct.unpack('8f', cap_and_pcs[5:]))

self.SOCKET_CAPACITANCE = scalers[0]

self.DAC.CHANS['PCS'].load_calibration_twopoint(scalers[1],

scalers[2]) # Slope and offset for current source

self.__calibrate_ctmu__(scalers[4:])

self.resistanceScaling = scalers[3] # SEN

self.aboutArray.append(['Capacitance[sock,550uA,55uA,5.5uA,.55uA]'] + scalers[:1] + scalers[4:])

self.aboutArray.append(['PCS slope,offset'] + scalers[1:3])

self.aboutArray.append(['SEN'] + [scalers[3]])

else:

self.SOCKET_CAPACITANCE = 42e-12 # approx

self.__print__('Cap and PCS calibration invalid') # ,cap_and_pcs[:10],'...')

# Load constants for ADC and DAC

polynomials = self.read_bulk_flash(self.ADC_POLYNOMIALS_LOCATION, 2048)

polyDict = {}

if polynomials[:9] == 'PSLab':

self.__print__('ADC calibration found...')

self.aboutArray.append(['Calibration Found'])

self.aboutArray.append([])

self.calibrated = True

adc_shifts = self.read_bulk_flash(self.ADC_SHIFTS_LOCATION1, 2048) + self.read_bulk_flash(

self.ADC_SHIFTS_LOCATION2, 2048)

adc_shifts = [CP.Byte.unpack(a)[0] for a in adc_shifts]

# print(adc_shifts)

self.__print__('ADC INL correction table loaded.')

self.aboutArray.append(['ADC INL Correction found', adc_shifts[0], adc_shifts[1], adc_shifts[2], '...'])

poly_sections = polynomials.split(

'STOP') # The 2K array is split into sections containing data for ADC_INL fit, ADC_CHANNEL fit, DAC_CHANNEL fit, PCS, CAP ...

adc_slopes_offsets = poly_sections[0]

dac_slope_intercept = poly_sections[1]

inl_slope_intercept = poly_sections[2]

# print('COMMON#########',self.__stoa__(slopes_offsets))

# print('DAC#########',self.__stoa__(dac_slope_intercept))

# print('ADC INL ############',self.__stoa__(inl_slope_intercept),len(inl_slope_intercept))

# Load calibration data for ADC channels into an array that'll be evaluated in the next code block

for a in adc_slopes_offsets.split('>|')[1:]:

self.__print__('\n', '>' * 20, a[:3], '<' * 20)

self.aboutArray.append([])

self.aboutArray.append(['ADC Channel', a[:3]])

self.aboutArray.append(['Gain', 'X^3', 'X^2', 'X', 'C'])

cals = a[5:]

polyDict[a[:3]] = []

for b in range(len(cals) // 16):

try:

poly = struct.unpack('4f', cals[b * 16:(b + 1) * 16])

except:

self.__print__(a[:3], ' not calibrated')

self.__print__(b, poly)

self.aboutArray.append([b] + ['%.3e' % v for v in poly])

polyDict[a[:3]].append(poly)

# Load calibration data (slopes and offsets) for ADC channels

inl_slope_intercept = struct.unpack('2f', inl_slope_intercept)

for a in self.analogInputSources:

self.analogInputSources[a].loadCalibrationTable(adc_shifts, inl_slope_intercept[0],

inl_slope_intercept[1])

if a in polyDict:

self.__print__('loading polynomials for ', a, polyDict[a])

self.analogInputSources[a].loadPolynomials(polyDict[a])

self.analogInputSources[a].calibrationReady = True

self.analogInputSources[a].regenerateCalibration()

# Load calibration data for DAC channels

for a in dac_slope_intercept.split('>|')[1:]:

NAME = a[:3] # Name of the DAC channel . PV1, PV2 ...

self.aboutArray.append([])

self.aboutArray.append(['Calibrated :', NAME])

try:

fits = struct.unpack('6f', a[5:])

self.__print__(NAME, ' calibrated', a[5:])

except:

self.__print__(NAME, ' not calibrated', a[5:], len(a[5:]), a)

continue

slope = fits[0]

intercept = fits[1]

fitvals = fits[2:]

if NAME in ['PV1', 'PV2', 'PV3']:

'''

DACX = np.linspace(self.DAC.CHANS[NAME].range[0], self.DAC.CHANS[NAME].range[1], 4096)

if NAME == 'PV1':

OFF = self.read_bulk_flash(self.DAC_SHIFTS_PV1A, 2048) + self.read_bulk_flash(

self.DAC_SHIFTS_PV1B, 2048)

elif NAME == 'PV2':

OFF = self.read_bulk_flash(self.DAC_SHIFTS_PV2A, 2048) + self.read_bulk_flash(

self.DAC_SHIFTS_PV2B, 2048)

elif NAME == 'PV3':

OFF = self.read_bulk_flash(self.DAC_SHIFTS_PV3A, 2048) + self.read_bulk_flash(

self.DAC_SHIFTS_PV3B, 2048)

OFF = np.array([ord(data) for data in OFF])

self.__print__('\n', '>' * 20, NAME, '<' * 20)

self.__print__('Offsets :', OFF[:20], '...')

fitfn = np.poly1d(fitvals)

YDATA = fitfn(DACX) - (OFF * slope + intercept)

LOOKBEHIND = 100

LOOKAHEAD = 100

OFF = np.array([np.argmin(

np.fabs(YDATA[max(B - LOOKBEHIND, 0):min(4095, B + LOOKAHEAD)] - DACX[B])) - (

B - max(B - LOOKBEHIND, 0)) for B in range(0, 4096)])

self.aboutArray.append(['Err min:', min(OFF), 'Err max:', max(OFF)])

self.DAC.CHANS[NAME].load_calibration_table(OFF)

def get_resistance(self):

V = self.get_average_voltage('SEN')

if V > 3.295: return np.Inf

I = (3.3 - V) / 5.1e3

res = V / I

return res * self.resistanceScaling

def __ignoreCalibration__(self):

print('CALIBRATION DISABLED')

for a in self.analogInputSources:

self.analogInputSources[a].__ignoreCalibration__()

self.analogInputSources[a].regenerateCalibration()

for a in ['PV1', 'PV2', 'PV3']: self.DAC.__ignoreCalibration__(a)

def __print__(self, *args):

if self.verbose:

for a in args:

print(a, end="")

print()

def __del__(self):

self.__print__('Closing PORT')

try:

self.H.fd.close()

except:

pass

def get_version(self):

"""

try:

return self.H.get_version(self.H.fd)

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

def getRadioLinks(self):

try:

return self.NRF.get_nodelist()

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

def newRadioLink(self, **args):

'''

from PSL.Peripherals import RadioLink

try:

return RadioLink(self.NRF, **args)

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

# -------------------------------------------------------------------------------------------------------------------#

# |================================================ANALOG SECTION====================================================|

# |This section has commands related to analog measurement and control. These include the oscilloscope routines, |

# |voltmeters, ammeters, and Programmable voltage sources. |

# -------------------------------------------------------------------------------------------------------------------#

def reconnect(self, **kwargs):

'''

try:

self.H.reconnect(**kwargs)

self.__runInitSequence__(**kwargs)

except Exception as ex:

self.errmsg = str(ex)

self.H.disconnect()

print(self.errmsg)

raise RuntimeError(self.errmsg)

def capture1(self, ch, ns, tg, *args, **kwargs):

"""

return self.capture_fullspeed(ch, ns, tg, *args, **kwargs)

def capture2(self, ns, tg, TraceOneRemap='CH1'):

"""

try:

self.capture_traces(2, ns, tg, TraceOneRemap)

time.sleep(1e-6 * self.samples * self.timebase + .01)

while not self.oscilloscope_progress()[0]:

pass

self.__fetch_channel__(1)

self.__fetch_channel__(2)

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

x = self.achans[0].get_xaxis()

y = self.achans[0].get_yaxis()

y2 = self.achans[1].get_yaxis()

# x,y2=self.fetch_trace(2)

return x, y, y2

def capture4(self, ns, tg, TraceOneRemap='CH1'):

"""

try:

self.capture_traces(4, ns, tg, TraceOneRemap)

time.sleep(1e-6 * self.samples * self.timebase + .01)

while not self.oscilloscope_progress()[0]:

pass

x, y = self.fetch_trace(1)

x, y2 = self.fetch_trace(2)

x, y3 = self.fetch_trace(3)

x, y4 = self.fetch_trace(4)

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

return x, y, y2, y3, y4

def capture_multiple(self, samples, tg, *args):

"""

if len(args) == 0:

self.__print__('please specify channels to record')

return

tg = int(tg * 8) / 8. # Round off the timescale to 1/8uS units

if (tg < 1.5): tg = int(1.5 * 8) / 8.

total_chans = len(args)

total_samples = samples * total_chans

if (total_samples > self.MAX_SAMPLES):

self.__print__('Sample limit exceeded. 10,000 total')

total_samples = self.MAX_SAMPLES

samples = self.MAX_SAMPLES / total_chans

CHANNEL_SELECTION = 0

for chan in args:

C = self.analogInputSources[chan].CHOSA

self.__print__(chan, C)

CHANNEL_SELECTION |= (1 << C)

self.__print__('selection', CHANNEL_SELECTION, len(args), hex(CHANNEL_SELECTION | ((total_chans - 1) << 12)))

try:

self.H.__sendByte__(CP.ADC)

self.H.__sendByte__(CP.CAPTURE_MULTIPLE)

self.H.__sendInt__(CHANNEL_SELECTION | ((total_chans - 1) << 12))

self.H.__sendInt__(total_samples) # total number of samples to record

self.H.__sendInt__(int(self.timebase * 8)) # Timegap between samples. 8MHz timer clock

self.H.__get_ack__()

self.__print__('wait')

time.sleep(1e-6 * total_samples * tg + .01)

self.__print__('done')

data = b''

for i in range(int(total_samples / self.data_splitting)):

self.H.__sendByte__(CP.ADC)

self.H.__sendByte__(CP.GET_CAPTURE_CHANNEL)

self.H.__sendByte__(0) # channel number . starts with A0 on PIC

self.H.__sendInt__(self.data_splitting)

self.H.__sendInt__(i * self.data_splitting)

data += self.H.fd.read(int(

self.data_splitting * 2)) # reading int by int sometimes causes a communication error. this works better.

self.H.__get_ack__()

if total_samples % self.data_splitting:

self.H.__sendByte__(CP.ADC)

self.H.__sendByte__(CP.GET_CAPTURE_CHANNEL)

self.H.__sendByte__(0) # channel number starts with A0 on PIC

self.H.__sendInt__(total_samples % self.data_splitting)

self.H.__sendInt__(total_samples - total_samples % self.data_splitting)

data += self.H.fd.read(int(2 * (

total_samples % self.data_splitting))) # reading int by int may cause packets to be dropped. this works better.

self.H.__get_ack__()

for a in range(int(total_samples)): self.buff[a] = CP.ShortInt.unpack(data[a * 2:a * 2 + 2])[0]

# self.achans[channel_number-1].yaxis = self.achans[channel_number-1].fix_value(self.buff[:samples])

yield np.linspace(0, tg * (samples - 1), samples)

for a in range(int(total_chans)):

yield self.buff[a:total_samples][::total_chans]

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

def __capture_fullspeed__(self, chan, samples, tg, *args, **kwargs):

tg = int(tg * 8) / 8. # Round off the timescale to 1/8uS units

if (tg < 0.5): tg = int(0.5 * 8) / 8.

if (samples > self.MAX_SAMPLES):

self.__print__('Sample limit exceeded. 10,000 max')

samples = self.MAX_SAMPLES

self.timebase = int(tg * 8) / 8.

self.samples = samples

CHOSA = self.analogInputSources[chan].CHOSA

try:

self.H.__sendByte__(CP.ADC)

if 'SET_LOW' in args:

self.H.__sendByte__(CP.SET_LO_CAPTURE)

elif 'SET_HIGH' in args:

self.H.__sendByte__(CP.SET_HI_CAPTURE)

elif 'FIRE_PULSES' in args:

self.H.__sendByte__(CP.PULSE_TRAIN)

self.__print__('firing sqr1 pulses for ', kwargs.get('interval', 1000), 'uS')

else:

self.H.__sendByte__(CP.CAPTURE_DMASPEED)

self.H.__sendByte__(CHOSA)

self.H.__sendInt__(samples) # total number of samples to record

self.H.__sendInt__(int(tg * 8)) # Timegap between samples. 8MHz timer clock

if 'FIRE_PULSES' in args:

t = kwargs.get('interval', 1000)

print('Firing for', t, 'uS')

self.H.__sendInt__(t)

time.sleep(

t * 1e-6) # Wait for hardware to free up from firing pulses(blocking call). Background capture starts immediately after this

self.H.__get_ack__()

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

def capture_fullspeed(self, chan, samples, tg, *args, **kwargs):

"""

self.__capture_fullspeed__(chan, samples, tg, *args, **kwargs)

time.sleep(1e-6 * self.samples * self.timebase + kwargs.get('interval', 0) * 1e-6 + 0.1)

x, y = self.__retrieveBufferData__(chan, self.samples, self.timebase)

return x, self.analogInputSources[chan].calPoly10(y)

def __capture_fullspeed_hr__(self, chan, samples, tg, *args):

tg = int(tg * 8) / 8. # Round off the timescale to 1/8uS units

if (tg < 1): tg = 1.

if (samples > self.MAX_SAMPLES):

self.__print__('Sample limit exceeded. 10,000 max')

samples = self.MAX_SAMPLES

self.timebase = int(tg * 8) / 8.

self.samples = samples

CHOSA = self.analogInputSources[chan].CHOSA

try:

self.H.__sendByte__(CP.ADC)

if 'SET_LOW' in args:

self.H.__sendByte__(CP.SET_LO_CAPTURE)

elif 'SET_HIGH' in args:

self.H.__sendByte__(CP.SET_HI_CAPTURE)

elif 'READ_CAP' in args:

self.H.__sendByte__(CP.MULTIPOINT_CAPACITANCE)

else:

self.H.__sendByte__(CP.CAPTURE_DMASPEED)

self.H.__sendByte__(CHOSA | 0x80)

self.H.__sendInt__(samples) # total number of samples to record

self.H.__sendInt__(int(tg * 8)) # Timegap between samples. 8MHz timer clock

self.H.__get_ack__()

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

def capture_fullspeed_hr(self, chan, samples, tg, *args):

try:

self.__capture_fullspeed_hr__(chan, samples, tg, *args)

time.sleep(1e-6 * self.samples * self.timebase + .01)

x, y = self.__retrieveBufferData__(chan, self.samples, self.timebase)

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

return x, self.analogInputSources[chan].calPoly12(y)

def __retrieveBufferData__(self, chan, samples, tg):

'''

data = b''

try:

for i in range(int(samples / self.data_splitting)):

self.H.__sendByte__(CP.ADC)

self.H.__sendByte__(CP.GET_CAPTURE_CHANNEL)

self.H.__sendByte__(0) # channel number . starts with A0 on PIC

self.H.__sendInt__(self.data_splitting)

self.H.__sendInt__(i * self.data_splitting)

data += self.H.fd.read(int(

self.data_splitting * 2)) # reading int by int sometimes causes a communication error. this works better.

self.H.__get_ack__()

if samples % self.data_splitting:

self.H.__sendByte__(CP.ADC)

self.H.__sendByte__(CP.GET_CAPTURE_CHANNEL)

self.H.__sendByte__(0) # channel number starts with A0 on PIC

self.H.__sendInt__(samples % self.data_splitting)

self.H.__sendInt__(samples - samples % self.data_splitting)

data += self.H.fd.read(int(2 * (

samples % self.data_splitting))) # reading int by int may cause packets to be dropped. this works better.

self.H.__get_ack__()

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

try:

for a in range(int(samples)): self.buff[a] = CP.ShortInt.unpack(data[a * 2:a * 2 + 2])[0]

except Exception as ex:

msg = "Incorrect Number of Bytes Received\n"

raise RuntimeError(msg)

# self.achans[channel_number-1].yaxis = self.achans[channel_number-1].fix_value(self.buff[:samples])

return np.linspace(0, tg * (samples - 1), samples), self.buff[:samples]

def capture_traces(self, num, samples, tg, channel_one_input='CH1', CH123SA=0, **kwargs):

"""

triggerornot = 0x80 if kwargs.get('trigger', True) else 0

self.timebase = tg

self.timebase = int(self.timebase * 8) / 8. # Round off the timescale to 1/8uS units

if channel_one_input not in self.analogInputSources: raise RuntimeError(

'Invalid input %s, not in %s' % (channel_one_input, str(self.analogInputSources.keys())))

CHOSA = self.analogInputSources[channel_one_input].CHOSA

try:

self.H.__sendByte__(CP.ADC)

if (num == 1):

if (self.timebase < 1.5): self.timebase = int(1.5 * 8) / 8.

if (samples > self.MAX_SAMPLES): samples = self.MAX_SAMPLES

self.achans[0].set_params(channel=channel_one_input, length=samples, timebase=self.timebase,

resolution=10, source=self.analogInputSources[channel_one_input])

self.H.__sendByte__(CP.CAPTURE_ONE) # read 1 channel

self.H.__sendByte__(CHOSA | triggerornot) # channelk number

elif (num == 2):

if (self.timebase < 1.75): self.timebase = int(1.75 * 8) / 8.

if (samples > self.MAX_SAMPLES / 2): samples = self.MAX_SAMPLES / 2

self.achans[0].set_params(channel=channel_one_input, length=samples, timebase=self.timebase,

resolution=10, source=self.analogInputSources[channel_one_input])

self.achans[1].set_params(channel='CH2', length=samples, timebase=self.timebase, resolution=10,

source=self.analogInputSources['CH2'])

self.H.__sendByte__(CP.CAPTURE_TWO) # capture 2 channels

self.H.__sendByte__(CHOSA | triggerornot) # channel 0 number

elif (num == 3 or num == 4):

if (self.timebase < 1.75): self.timebase = int(1.75 * 8) / 8.

if (samples > self.MAX_SAMPLES / 4): samples = self.MAX_SAMPLES / 4

self.achans[0].set_params(channel=channel_one_input, length=samples, timebase=self.timebase, \

resolution=10, source=self.analogInputSources[channel_one_input])

for a in range(1, 4):

chans = ['NONE', 'CH2', 'CH3', 'MIC']

self.achans[a].set_params(channel=chans[a], length=samples, timebase=self.timebase, \

resolution=10, source=self.analogInputSources[chans[a]])

self.H.__sendByte__(CP.CAPTURE_FOUR) # read 4 channels

self.H.__sendByte__(CHOSA | (CH123SA << 4) | triggerornot) # channel number

self.samples = samples

self.H.__sendInt__(samples) # number of samples per channel to record

self.H.__sendInt__(int(self.timebase * 8)) # Timegap between samples. 8MHz timer clock

self.H.__get_ack__()

self.channels_in_buffer = num

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

def capture_highres_traces(self, channel, samples, tg, **kwargs):

"""

triggerornot = 0x80 if kwargs.get('trigger', True) else 0

self.timebase = tg

try:

self.H.__sendByte__(CP.ADC)

CHOSA = self.analogInputSources[channel].CHOSA

if (self.timebase < 3): self.timebase = 3

if (samples > self.MAX_SAMPLES): samples = self.MAX_SAMPLES

self.achans[0].set_params(channel=channel, length=samples, timebase=self.timebase, resolution=12,

source=self.analogInputSources[channel])

self.H.__sendByte__(CP.CAPTURE_12BIT) # read 1 channel

self.H.__sendByte__(CHOSA | triggerornot) # channelk number

self.samples = samples

self.H.__sendInt__(samples) # number of samples to read

self.H.__sendInt__(int(self.timebase * 8)) # Timegap between samples. 8MHz timer clock

self.H.__get_ack__()

self.channels_in_buffer = 1

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

def fetch_trace(self, channel_number):

"""

self.__fetch_channel__(channel_number)

return self.achans[channel_number - 1].get_xaxis(), self.achans[channel_number - 1].get_yaxis()

def oscilloscope_progress(self):

"""

conversion_done = 0

samples = 0

try:

self.H.__sendByte__(CP.ADC)

self.H.__sendByte__(CP.GET_CAPTURE_STATUS)

conversion_done = self.H.__getByte__()

samples = self.H.__getInt__()

self.H.__get_ack__()

except Exception as ex:

self.raiseException(ex, "Communication Error , Function : " + inspect.currentframe().f_code.co_name)

return conversion_done, samples

def __fetch_channel__(self, channel_number):

"""

samples = self.achans[channel_number - 1].length

if (channel_number > self.channels_in_buffer):

self.__print__('Channel unavailable')

return False

data = b''

try:

for i in range(int(samples / self.data_splitting)):