'''

obj = ScienceLab(**kwargs)

if obj.H.fd is not None:

return obj

else:

print('Err')

"""

BAUD = 1000000

WType = {'SI1': 'sine', 'SI2': '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.sine1freq = None

self.sine2freq = None

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

self.aboutArray = []

self.errmsg = ''

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

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

self.logic_analyzer = LogicAnalyzer(device=self.H)

self.oscilloscope = Oscilloscope(device=self.H)

self.__runInitSequence__(**kwargs)

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.buff = np.zeros(10000)

self.SOCKET_CAPACITANCE = 42e-12 # 42e-12 is typical for the FOSSASIA PSLab. Actual values require calibration (currently not supported).

self.resistanceScaling = 1.

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

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.oscilloscope._channels[a].gain = 1

for a in ['SI1', 'SI2']: 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)

def get_resistance(self):

V = self.get_average_voltage('RES')

if V > 3.295: return np.Inf

I = (3.3 - V) / 5.1e3

res = V / I

return res * self.resistanceScaling

def __print__(self, *args):

if self.verbose:

for a in args:

print(a, end="")

print()

def get_version(self):

"""

return self.H.get_version()

def getRadioLinks(self):

return self.NRF.get_nodelist()

def newRadioLink(self, **args):

'''

from PSL.Peripherals import RadioLink

return RadioLink(self.NRF, **args)

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

# |================================================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):

'''

self.H.reconnect(**kwargs)

self.__runInitSequence__(**kwargs)

def get_voltage(self, channel_name, **kwargs):

self.voltmeter_autorange(channel_name)

return self.get_average_voltage(channel_name, **kwargs)

def voltmeter_autorange(self, channel_name):

try:

self.oscilloscope._channels[channel_name].gain = 1

except TypeError: # channel_name is not CH1 or CH2.

return 1

V = self.get_average_voltage(channel_name)

return self.__autoSelectRange__(channel_name, V)

def __autoSelectRange__(self, channel_name, V):

keys = [8, 4, 3, 2, 1.5, 1, .5, 0]

cutoffs = {8: 1, 4: 2, 3: 4, 2: 5, 1.5: 8, 1.: 10, .5: 16, 0: 32}

for a in keys:

if abs(V) > a:

g = cutoffs[a]

break

self.oscilloscope._channels[channel_name].gain = g

return g

def __autoRangeScope__(self, tg):

x, y1, y2 = self.oscilloscope.capture(2, 1000, tg)

self.__autoSelectRange__('CH1', max(abs(y1)))

self.__autoSelectRange__('CH2', max(abs(y2)))

def get_average_voltage(self, channel_name, **kwargs):

"""

self.oscilloscope._channels[channel_name].resolution = 12

scale = self.oscilloscope._channels[channel_name].scale

vals = [self.__get_raw_average_voltage__(channel_name, **kwargs) for a in range(int(kwargs.get('samples', 1)))]

# if vals[0]>2052:print (vals)

val = np.average([scale(a) for a in vals])

return val

def __get_raw_average_voltage__(self, channel_name, **kwargs):

"""

chosa = self.oscilloscope._channels[channel_name].chosa

self.H.__sendByte__(CP.ADC)

self.H.__sendByte__(CP.GET_VOLTAGE_SUMMED)

self.H.__sendByte__(chosa)

V_sum = self.H.__getInt__()

self.H.__get_ack__()

return V_sum / 16. # sum(V)/16.0 #

def fetch_buffer(self, starting_position=0, total_points=100):

"""

self.H.__sendByte__(CP.COMMON)

self.H.__sendByte__(CP.RETRIEVE_BUFFER)

self.H.__sendInt__(starting_position)

self.H.__sendInt__(total_points)

for a in range(int(total_points)): self.buff[a] = self.H.__getInt__()

self.H.__get_ack__()

def clear_buffer(self, starting_position, total_points):

"""

self.H.__sendByte__(CP.COMMON)

self.H.__sendByte__(CP.CLEAR_BUFFER)

self.H.__sendInt__(starting_position)

self.H.__sendInt__(total_points)

self.H.__get_ack__()

def fill_buffer(self, starting_position, point_array):

"""

self.H.__sendByte__(CP.COMMON)

self.H.__sendByte__(CP.FILL_BUFFER)

self.H.__sendInt__(starting_position)

self.H.__sendInt__(len(point_array))

for a in point_array:

self.H.__sendInt__(int(a))

self.H.__get_ack__()

def start_streaming(self, tg, channel='CH1'):

"""

chosa = self.oscilloscope.channels[channel].chosa

if (self.streaming): self.stop_streaming()

self.H.__sendByte__(CP.ADC)

self.H.__sendByte__(CP.START_ADC_STREAMING)

self.H.__sendByte__(chosa)

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

self.streaming = True

def stop_streaming(self):

"""

if (self.streaming):

self.H.__sendByte__(CP.STOP_STREAMING)

self.H.fd.read(20000)

self.H.fd.flush()

else:

self.__print__('not streaming')

self.streaming = False

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

# |===============================================DIGITAL SECTION====================================================|

# |This section has commands related to digital measurement and control. These include the Logic Analyzer, frequency |

# |measurement calls, timing routines, digital outputs etc |

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

def set_state(self, **kwargs):

"""

data = 0

if 'SQR1' in kwargs:

data |= 0x10 | (kwargs.get('SQR1'))

if 'SQR2' in kwargs:

data |= 0x20 | (kwargs.get('SQR2') << 1)

if 'SQR3' in kwargs:

data |= 0x40 | (kwargs.get('SQR3') << 2)

if 'SQR4' in kwargs:

data |= 0x80 | (kwargs.get('SQR4') << 3)

self.H.__sendByte__(CP.DOUT)

self.H.__sendByte__(CP.SET_STATE)

self.H.__sendByte__(data)

self.H.__get_ack__()

def __charge_cap__(self, state, t):

self.H.__sendByte__(CP.ADC)

self.H.__sendByte__(CP.SET_CAP)

self.H.__sendByte__(state)

self.H.__sendInt__(t)

self.H.__get_ack__()

def __capture_capacitance__(self, samples, tg):

raise NotImplementedError

def capacitance_via_RC_discharge(self):

cap = self.get_capacitor_range()[1]

T = 2 * cap * 20e3 * 1e6 # uS

samples = 500

if T > 5000 and T < 10e6:

if T > 50e3: samples = 250

RC = self.__capture_capacitance__(samples, int(T / samples))[3][1]

return RC / 10e3

else:

self.__print__('cap out of range %f %f' % (T, cap))

return 0

def __get_capacitor_range__(self, ctime):

self.__charge_cap__(0, 30000)

self.H.__sendByte__(CP.COMMON)

self.H.__sendByte__(CP.GET_CAP_RANGE)

self.H.__sendInt__(ctime)

V_sum = self.H.__getInt__()

self.H.__get_ack__()

V = V_sum * 3.3 / 16 / 4095

C = -ctime * 1e-6 / 1e4 / np.log(1 - V / 3.3)

return V, C

def get_capacitor_range(self):

"""

t = 10

P = [1.5, 50e-12]

for a in range(4):

P = list(self.__get_capacitor_range__(50 * (10 ** a)))

if (P[0] > 1.5):

if a == 0 and P[0] > 3.28: # pico farads range. Values will be incorrect using this method

P[1] = 50e-12

break

return P

def get_capacitance(self): # time in uS

"""

GOOD_VOLTS = [2.5, 2.8]

CT = 10

CR = 1

iterations = 0

start_time = time.time()

while (time.time() - start_time) < 1:

# self.__print__('vals',CR,',',CT)

if CT > 65000:

self.__print__('CT too high')

return self.capacitance_via_RC_discharge()

V, C = self.__get_capacitance__(CR, 0, CT)

# print(CR,CT,V,C)

if CT > 30000 and V < 0.1:

self.__print__('Capacitance too high for this method')

return 0

elif V > GOOD_VOLTS[0] and V < GOOD_VOLTS[1]:

return C

elif V < GOOD_VOLTS[0] and V > 0.01 and CT < 40000:

if GOOD_VOLTS[0] / V > 1.1 and iterations < 10:

CT = int(CT * GOOD_VOLTS[0] / V)

iterations += 1

self.__print__('increased CT ', CT)

elif iterations == 10:

return 0

else:

return C

elif V <= 0.1 and CR < 3:

CR += 1

elif CR == 3:

self.__print__('Capture mode ')

return self.capacitance_via_RC_discharge()

def __get_capacitance__(self, current_range, trim, Charge_Time): # time in uS

self.__charge_cap__(0, 30000)

self.H.__sendByte__(CP.COMMON)

self.H.__sendByte__(CP.GET_CAPACITANCE)

self.H.__sendByte__(current_range)

if (trim < 0):

self.H.__sendByte__(int(31 - abs(trim) / 2) | 32)

else:

self.H.__sendByte__(int(trim / 2))

self.H.__sendInt__(Charge_Time)

time.sleep(Charge_Time * 1e-6 + .02)

VCode = self.H.__getInt__()

V = 3.3 * VCode / 4095

self.H.__get_ack__()

Charge_Current = self.currents[current_range] * (100 + trim) / 100.0

if V:

C = (Charge_Current * Charge_Time * 1e-6 / V - self.SOCKET_CAPACITANCE) / self.currentScalers[

current_range]

else:

C = 0

return V, C

def get_temperature(self):

"""

cs = 3

V = self.get_ctmu_voltage(0b11110, cs, 0)

if cs == 1:

return (646 - V * 1000) / 1.92 # current source = 1

elif cs == 2:

return (701.5 - V * 1000) / 1.74 # current source = 2

elif cs == 3:

return (760 - V * 1000) / 1.56 # current source = 3

def get_ctmu_voltage(self, channel, Crange, tgen=1):

"""

if channel == 'CAP': channel = 5

self.H.__sendByte__(CP.COMMON)

self.H.__sendByte__(CP.GET_CTMU_VOLTAGE)

self.H.__sendByte__((channel) | (Crange << 5) | (tgen << 7))

v = self.H.__getInt__() # 16*voltage across the current source

self.H.__get_ack__()

V = 3.3 * v / 16 / 4095.

return V

def __start_ctmu__(self, Crange, trim, tgen=1):

self.H.__sendByte__(CP.COMMON)

self.H.__sendByte__(CP.START_CTMU)

self.H.__sendByte__((Crange) | (tgen << 7))

self.H.__sendByte__(trim)

self.H.__get_ack__()

def __stop_ctmu__(self):

self.H.__sendByte__(CP.COMMON)

self.H.__sendByte__(CP.STOP_CTMU)

self.H.__get_ack__()

def resetHardware(self):

"""

self.H.__sendByte__(CP.COMMON)

self.H.__sendByte__(CP.RESTORE_STANDALONE)

def read_flash(self, page, location):

"""

self.H.__sendByte__(CP.FLASH)

self.H.__sendByte__(CP.READ_FLASH)

self.H.__sendByte__(page) # send the page number. 20 pages with 2K bytes each

self.H.__sendByte__(location) # send the location

ss = self.H.fd.read(16)

self.H.__get_ack__()

return ss

def read_bulk_flash(self, page, numbytes):

"""

self.H.__sendByte__(CP.FLASH)

self.H.__sendByte__(CP.READ_BULK_FLASH)

bytes_to_read = numbytes

if numbytes % 2: bytes_to_read += 1 # bytes+1 . stuff is stored as integers (byte+byte) in the hardware

self.H.__sendInt__(bytes_to_read)

self.H.__sendByte__(page)

ss = self.H.fd.read(int(bytes_to_read))

self.H.__get_ack__()

if numbytes % 2: return ss[:-1] # Kill the extra character we read. Don't surprise the user with extra data

return ss

def write_flash(self, page, location, string_to_write):

"""

while (len(string_to_write) < 16): string_to_write += '.'

self.H.__sendByte__(CP.FLASH)

self.H.__sendByte__(CP.WRITE_FLASH) # indicate a flash write coming through

self.H.__sendByte__(page) # send the page number. 20 pages with 2K bytes each

self.H.__sendByte__(location) # send the location

self.H.fd.write(string_to_write)

time.sleep(0.1)

self.H.__get_ack__()

def write_bulk_flash(self, location, data):

"""

if (type(data) == str): data = [ord(a) for a in data]

if len(data) % 2 == 1: data.append(0)

self.H.__sendByte__(CP.FLASH)

self.H.__sendByte__(CP.WRITE_BULK_FLASH) # indicate a flash write coming through

self.H.__sendInt__(len(data)) # send the length

self.H.__sendByte__(location)

for n in range(len(data)):

self.H.__sendByte__(data[n])

self.H.__get_ack__()

# verification by readback

tmp = [ord(a) for a in self.read_bulk_flash(location, len(data))]

print('Verification done', tmp == data)

if tmp != data: raise Exception('Verification by readback failed')

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

# |===============================================WAVEGEN SECTION====================================================|

# |This section has commands related to waveform generators SI1, SI2, PWM outputs, servo motor control etc. |

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

def set_wave(self, chan, freq):

"""

if chan == 'SI1':

self.set_w1(freq)

elif chan == 'SI2':

self.set_w2(freq)

def set_sine1(self, freq):

"""

return self.set_w1(freq, 'sine')

def set_sine2(self, freq):

"""

return self.set_w2(freq, 'sine')

def set_w1(self, freq, waveType=None):

"""

if freq < 0.1:

self.__print__('freq too low')

return 0

elif freq < 1100:

HIGHRES = 1

table_size = 512

else:

HIGHRES = 0

table_size = 32

if waveType: # User wants to set a particular waveform type. sine or tria

if waveType in ['sine', 'tria']:

if (self.WType['SI1'] != waveType):

self.load_equation('SI1', waveType)

else:

print('Not a valid waveform. try sine or tria')

p = [1, 8, 64, 256]

prescaler = 0

while prescaler <= 3:

wavelength = int(round(64e6 / freq / p[prescaler] / table_size))

freq = (64e6 / wavelength / p[prescaler] / table_size)

if wavelength < 65525: break

prescaler += 1

if prescaler == 4:

self.__print__('out of range')

return 0

self.H.__sendByte__(CP.WAVEGEN)

self.H.__sendByte__(CP.SET_SINE1)

self.H.__sendByte__(HIGHRES | (prescaler << 1)) # use larger table for low frequencies

self.H.__sendInt__(wavelength - 1)

self.H.__get_ack__()

self.sine1freq = freq

return freq

def set_w2(self, freq, waveType=None):

"""

if freq < 0.1:

self.__print__('freq too low')

return 0

elif freq < 1100:

HIGHRES = 1

table_size = 512

else:

HIGHRES = 0

table_size = 32

if waveType: # User wants to set a particular waveform type. sine or tria

if waveType in ['sine', 'tria']:

if (self.WType['SI2'] != waveType):

self.load_equation('SI2', waveType)

else:

print('Not a valid waveform. try sine or tria')

p = [1, 8, 64, 256]

prescaler = 0

while prescaler <= 3:

wavelength = int(round(64e6 / freq / p[prescaler] / table_size))

freq = (64e6 / wavelength / p[prescaler] / table_size)

if wavelength < 65525: break

prescaler += 1

if prescaler == 4:

self.__print__('out of range')

return 0

self.H.__sendByte__(CP.WAVEGEN)

self.H.__sendByte__(CP.SET_SINE2)

self.H.__sendByte__(HIGHRES | (prescaler << 1)) # use larger table for low frequencies

self.H.__sendInt__(wavelength - 1)

self.H.__get_ack__()

self.sine2freq = freq

return freq

def readbackWaveform(self, chan):

"""

if chan == 'SI1':

return self.sine1freq

elif chan == 'SI2':

return self.sine2freq

elif chan[:3] == 'SQR':

return self.sqrfreq.get(chan, None)

def set_waves(self, freq, phase, f2=None):

"""

if f2:

freq2 = f2

else:

freq2 = freq

if freq < 0.1:

self.__print__('freq1 too low')

return 0

elif freq < 1100:

HIGHRES = 1

table_size = 512

else:

HIGHRES = 0

table_size = 32

if freq2 < 0.1:

self.__print__('freq2 too low')

return 0

elif freq2 < 1100:

HIGHRES2 = 1

table_size2 = 512

else:

HIGHRES2 = 0

table_size2 = 32

if freq < 1. or freq2 < 1.:

self.__print__('extremely low frequencies will have reduced amplitudes due to AC coupling restrictions')

p = [1, 8, 64, 256]

prescaler1 = 0

while prescaler1 <= 3:

wavelength = int(round(64e6 / freq / p[prescaler1] / table_size))

retfreq = (64e6 / wavelength / p[prescaler1] / table_size)

if wavelength < 65525: break

prescaler1 += 1

if prescaler1 == 4:

self.__print__('#1 out of range')

return 0

p = [1, 8, 64, 256]

prescaler2 = 0

while prescaler2 <= 3:

wavelength2 = int(round(64e6 / freq2 / p[prescaler2] / table_size2))

retfreq2 = (64e6 / wavelength2 / p[prescaler2] / table_size2)

if wavelength2 < 65525: break

prescaler2 += 1

if prescaler2 == 4:

self.__print__('#2 out of range')

return 0

phase_coarse = int(table_size2 * (phase) / 360.)

phase_fine = int(wavelength2 * (phase - (phase_coarse) * 360. / table_size2) / (360. / table_size2))

self.H.__sendByte__(CP.WAVEGEN)

self.H.__sendByte__(CP.SET_BOTH_WG)

self.H.__sendInt__(wavelength - 1) # not really wavelength. time between each datapoint

self.H.__sendInt__(wavelength2 - 1) # not really wavelength. time between each datapoint

self.H.__sendInt__(phase_coarse) # table position for phase adjust

self.H.__sendInt__(phase_fine) # timer delay / fine phase adjust

self.H.__sendByte__((prescaler2 << 4) | (prescaler1 << 2) | (HIGHRES2 << 1) | (

HIGHRES)) # use larger table for low frequencies

self.H.__get_ack__()

self.sine1freq = retfreq

self.sine2freq = retfreq2

return retfreq

def load_equation(self, chan, function, span=None, **kwargs):

'''

if function == 'sine' or function == np.sin:

function = np.sin

span = [0, 2 * np.pi]

self.WType[chan] = 'sine'

elif function == 'tria':

function = lambda x: abs(x % 4 - 2) - 1

span = [-1, 3]

self.WType[chan] = 'tria'

else:

self.WType[chan] = 'arbit'

self.__print__('reloaded wave equation for %s : %s' % (chan, self.WType[chan]))

x1 = np.linspace(span[0], span[1], 512 + 1)[:-1]

y1 = function(x1)

self.load_table(chan, y1, self.WType[chan], **kwargs)

def load_table(self, chan, points, mode='arbit', **kwargs):

'''