SEEL package

Submodules

SEEL.Peripherals module

class SEEL.Peripherals.DACCHAN(name, span, channum, **kwargs)[source]
apply_calibration(v)[source]
load_calibration_table(table)[source]
load_calibration_twopoint(slope, offset)[source]
class SEEL.Peripherals.I2C(H)[source]

Methods to interact with the I2C port. An instance of Labtools.Packet_Handler must be passed to the init function

Example:: Read Values from an HMC5883L 3-axis Magnetometer(compass) [GY-273 sensor] connected to the I2C port
>>> ADDRESS = 0x1E
>>> from SEEL import interface
>>> I = interface.connect() 
#Alternately, you may skip using I2C as a child instance of Interface, 
#and instead use I2C=SEEL.Peripherals.I2C(SEEL.packet_handler.Handler())

# writing to 0x1E, set gain(0x01) to smallest(0 : 1x) >>> I.I2C.bulkWrite(ADDRESS,[0x01,0])

# writing to 0x1E, set mode conf(0x02), continuous measurement(0) >>> I.I2C.bulkWrite(ADDRESS,[0x02,0])

# read 6 bytes from addr register on I2C device located at ADDRESS >>> vals = I.I2C.bulkRead(ADDRESS,addr,6)

>>> from numpy import int16
#conversion to signed datatype
>>> x=int16((vals[0]<<8)|vals[1])
>>> y=int16((vals[2]<<8)|vals[3])
>>> z=int16((vals[4]<<8)|vals[5])
>>> print (x,y,z)
capture(address, location, sample_length, total_samples, tg, *args)[source]

Blocking call that fetches data from I2C sensors like an oscilloscope fetches voltage readings

Arguments  
address Address of the I2C sensor
location Address of the register to read from
sample_length Each sample can be made up of multiple bytes startng from <location> . such as 3-axis data
total_samples Total samples to acquire. Total bytes fetched = total_samples*sample_length
tg timegap between samples (in uS)

Example

>>> from pylab import *
>>> I=interface.Interface()
>>> x,y1,y2,y3,y4 = I.capture_multiple(800,1.75,'CH1','CH2','MIC','SEN')
>>> plot(x,y1)              
>>> plot(x,y2)              
>>> plot(x,y3)              
>>> plot(x,y4)              
>>> show()              
Returns:Arrays X(timestamps),Y1,Y2 ...
config(freq, verbose=True)[source]

Sets frequency for I2C transactions

Arguments  
freq I2C frequency
enable_smbus()[source]
init()[source]
pullSCLLow(uS)[source]

Hold SCL pin at 0V for a specified time period. Used by certain sensors such as MLX90316 PIR for initializing.

Arguments  
uS Time(in uS) to hold SCL output at 0 Volts
read(length)[source]

Reads a fixed number of data bytes from I2C device. Fetches length-1 bytes with acknowledge bits for each, +1 byte with Nack.

Arguments  
length number of bytes to read from I2C bus
readBulk(device_address, register_address, bytes_to_read)[source]
read_end()[source]
read_repeat()[source]
read_status()[source]
restart(address, rw)[source]

Initiates I2C transfer to address

Arguments  
address I2C slave address
rw Read/write. * 0 for writing * 1 for reading.
scan(frequency=100000, verbose=False)[source]

Scan I2C port for connected devices

Arguments  
Frequency I2C clock frequency
Returns:Array of addresses of connected I2C slave devices
send(data)[source]

SENDS data over I2C. The I2C bus needs to be initialized and set to the correct slave address first. Use I2C.start(address) for this.

Arguments  
data Sends data byte over I2C bus
Returns:Nothing
send_burst(data)[source]

SENDS data over I2C. The function does not wait for the I2C to finish before returning. It is used for sending large packets quickly. The I2C bus needs to be initialized and set to the correct slave address first. Use start(address) for this.

Arguments  
data Sends data byte over I2C bus
Returns:Nothing
simpleRead(addr, numbytes)[source]

Read bytes from I2C slave without first transmitting the read location.

Arguments  
addr Address of I2C slave
numbytes Total Bytes to read
start(address, rw)[source]

Initiates I2C transfer to address via the I2C port

Arguments  
address I2C slave address
rw Read/write. - 0 for writing - 1 for reading.
stop()[source]

stops I2C transfer

Returns:Nothing
wait()[source]

wait for I2C

Returns:Nothing
writeBulk(device_address, bytestream)[source]

write bytes to I2C slave

Arguments  
device_address Address of I2C slave
bytestream List of bytes to write
class SEEL.Peripherals.MCP4728(H, vref=3.3, devid=0)[source]
GAINWRITE = 192
GENERALCALL = 0
POWERDOWNWRITE = 160
RESET = 6
SEQWRITE = 80
UPDATE = 8
VREFWRITE = 128
WAKEUP = 9
WRITEALL = 64
WRITEONE = 88
defaultVDD = 3300
setVoltage(name, v)[source]
stat()[source]
class SEEL.Peripherals.NRF24L01(H)[source]
ACK_PAYLOAD = 168
ACK_PAYLOAD_SIZE = 0
ACTIVATE = 80
ADC_COMMANDS = 1
CD = 9
CURRENT_ADDRESS = 11184641
DYNPD = 28
EN_AA = 1
EN_RXADDR = 2
FEATURE = 29
FIFO_STATUS = 23
FLUSH_RX = 226
FLUSH_TX = 225
GuessingScan()[source]

Scans the I2C bus and also prints the possible devices associated with each found address

I2C_COMMANDS = 2
I2C_CONFIG = 64
I2C_READ = 80
I2C_TRANSACTION = 0
I2C_WRITE = 16
I2C_scan()[source]

Scans the I2C bus and returns a list of live addresses

NODELIST_MAXLENGTH = 15
NRF_COMMANDS = 3
NRF_CONFIG = 0
NRF_READ_REGISTER = 0
NRF_STATUS = 7
NRF_WRITE_REGISTER = 16
OBSERVE_TX = 8
PAYLOAD_SIZE = 0
PULL_SCL_LOW = 48
READ_ADC = 0
READ_PAYLOAD_SIZE = 0
RF_CH = 5
RF_SETUP = 6
RX_ADDR_P0 = 10
RX_ADDR_P1 = 11
RX_ADDR_P2 = 12
RX_ADDR_P3 = 13
RX_ADDR_P4 = 14
RX_ADDR_P5 = 15
RX_PAYLOAD = 97
RX_PW_P0 = 17
RX_PW_P1 = 18
RX_PW_P2 = 19
RX_PW_P3 = 20
RX_PW_P4 = 21
RX_PW_P5 = 22
R_REG = 0
R_RX_PL_WID = 96
R_STATUS = 255
SCAN_I2C = 32
SETUP_AW = 3
SETUP_RETR = 4
TX_ADDR = 16
TX_PAYLOAD = 160
W_REG = 32
connected = False
fetch_report(num)[source]
flush()[source]

Flushes the TX and RX FIFOs

get_nodelist()[source]

Refer to the variable ‘nodelist’ if you simply want a list of nodes that either registered while your code was running , or were loaded from the firmware buffer(max 15 entries)

If you plan to use more than 15 nodes, and wish to register their addresses without having to feed them manually, then this function must be called each time before the buffer resets.

The dictionary object returned by this function [addresses paired with arrays containing their registered sensors] is filtered by checking with each node if they are alive.

get_status()[source]

Returns a byte representing the STATUS register on the radio. Refer to NRF24L01+ documentation for further details

hasData()[source]

Check if the RX FIFO contains data

init()[source]
init_shockburst_receiver(**args)[source]

Puts the radio into receive mode. Dynamic Payload with auto acknowledge is enabled.

init_shockburst_transmitter(**args)[source]

Puts the radio into transmit mode. Dynamic Payload with auto acknowledge is enabled. upto 5 retransmits with 1ms delay between each in case a node doesn’t respond in time Receivers must acknowledge payloads

isAlive(addr)[source]
nodelist = {}
nodepos = 0
power_down()[source]
read_payload(numbytes)[source]
read_register(address)[source]

Read the value of any of the configuration registers on the radio module.

rxchar()[source]

Receives a 1 Byte payload

rxmode()[source]

Puts the radio into listening mode.

selectAddress(address)[source]

Sets RX_ADDR_P0 and TX_ADDR to the specified address.

start_token_manager()[source]
stop_token_manager()[source]
total_tokens()[source]
transaction(data, **args)[source]
transactionWithRetries(data, **args)[source]
triggerAll(val)[source]
txchar(char)[source]

Transmits a single character

txmode()[source]

Puts the radio into transmit mode.

write_ack_payload(data, pipe)[source]
write_address(register, address)[source]

register can be TX_ADDR, RX_ADDR_P0 -> RX_ADDR_P5 3 byte address. eg 0xFFABXX . XX cannot be FF if RX_ADDR_P1 needs to be used along with any of the pipes from P2 to P5, then RX_ADDR_P1 must be updated last. Addresses from P1-P5 must share the first two bytes.

write_command(cmd)[source]
write_payload(data, verbose=False, **args)[source]
write_register(address, value)[source]

write a byte to any of the configuration registers on the Radio. address byte can either be located in the NRF24L01+ manual, or chosen from some of the constants defined in this module.

ADC_COMMANDS = 1
I2C_COMMANDS = 2
I2C_CONFIG = 64
I2C_READ = 80
I2C_TRANSACTION = 0
I2C_WRITE = 16
I2C_scan()[source]
MISC_COMMANDS = 4
NRF_COMMANDS = 3
NRF_READ_REGISTER = 0
NRF_WRITE_REGISTER = 16
PULL_SCL_LOW = 48
READ_ADC = 0
SCAN_I2C = 32
WS2812B(cols)[source]

set shade of WS2182 LED on CS1/RC0

Arguments  
cols
2Darray [[R,G,B],[R2,G2,B2],[R3,G3,B3]...]
brightness of R,G,B ( 0-255 )

example:

>>> WS2812B([[10,0,0],[0,10,10],[10,0,10]])
#sets red, cyan, magenta to three daisy chained LEDs
WS2812B_CMD = 0
configI2C(freq)[source]
pullSCLLow(t_ms)[source]
readADC(channel)[source]
readBulk(I2C_addr, regaddress, numbytes)[source]
readI2C(I2C_addr, regaddress, numbytes)[source]
read_register(reg)[source]
simpleRead(I2C_addr, numbytes)[source]
writeBulk(I2C_addr, bytes)[source]
writeI2C(I2C_addr, regaddress, bytes)[source]
write_register(reg, val)[source]
class SEEL.Peripherals.SPI(H)[source]

Methods to interact with the SPI port. An instance of Packet_Handler must be passed to the init function

send16(value)[source]

SENDS 16-bit data over SPI

Arguments  
value value to transmit
Returns:value returned by slave device
Return type:int
send16_burst(value)[source]

SENDS 16-bit data over SPI no acknowledge/return value

Arguments  
value value to transmit
Returns:nothing
send8(value)[source]

SENDS 8-bit data over SPI

Arguments  
value value to transmit
Returns:value returned by slave device
send8_burst(value)[source]

SENDS 8-bit data over SPI No acknowledge/return value

Arguments  
value value to transmit
Returns:Nothing
set_cs(channel, state)[source]

Enable or disable a chip select

Arguments  
channel ‘CS1’,’CS2’
state 1 for HIGH, 0 for LOW
set_parameters(primary_prescaler=0, secondary_prescaler=2, CKE=1, CKP=0, SMP=1)[source]

sets SPI parameters.

Arguments  
primary_pres Primary Prescaler(0,1,2,3) for 64MHz clock->(64:1,16:1,4:1,1:1)
secondary_pres Secondary prescaler(0,1,..7)->(8:1,7:1,..1:1)
CKE CKE 0 or 1.
CKP CKP 0 or 1.
start(channel)[source]

selects SPI channel to enable. Basically lowers the relevant chip select pin .

Arguments  
channel 1-7 ->[PGA1 connected to CH1,PGA2,PGA3,PGA4,PGA5,external chip select 1,external chip select 2] 8 -> sine1 9 -> sine2
stop(channel)[source]

selects SPI channel to disable. Sets the relevant chip select pin to HIGH.

Arguments  
channel 1-7 ->[PGA1 connected to CH1,PGA2,PGA3,PGA4,PGA5,external chip select 1,external chip select 2]

SEEL.achan module

class SEEL.achan.analogAcquisitionChannel(a)[source]

This class takes care of oscilloscope data fetched from the device. Each instance may be linked to a particular input. Since only up to two channels may be captured at a time with the vLabtool, only two instances will be required

Each instance will be linked to a particular inputSource instance by the capture routines. When data is requested , it will return after applying calibration and gain details stored in the selected inputSource

fix_value(val)[source]
get_xaxis()[source]
get_yaxis()[source]
regenerate_xaxis()[source]
set_params(**keys)[source]
set_xval(pos, val)[source]
set_yval(pos, val)[source]
class SEEL.achan.analogInputSource(name, **args)[source]
calPoly10 = poly1d([ 0.00322581, 0. ])
calPoly12 = poly1d([ 0.00080586, 0. ])
calibrationReady = False
defaultOffsetCode = 0
gain = None
gainEnabled = False
gainPGA = None
gain_values = [1, 2, 4, 5, 8, 10, 16, 32]
inRange(val)[source]
inversion = 1.0
inverted = False
loadCalibrationTable(table, slope, intercept)[source]
loadPolynomials(polys)[source]
regenerateCalibration()[source]
setGain(g)[source]

SEEL.analyticsClass module

class SEEL.analyticsClass.analyticsClass[source]

This class contains methods that allow mathematical analysis such as curve fitting

amp_spectrum(v, si, nhar=8)[source]
arbitFit(xReal, yReal, func, **args)[source]
dampedSine(x, amp, freq, phase, offset, damp)[source]

A damped sine wave function

find_frequency(v, si)[source]
fit_exp(t, v)[source]
func(x, a, b, c)[source]
getGuessValues(xReal, yReal, func='sine')[source]
sineFit(xReal, yReal, **kwargs)[source]
sineFit2(x, y)[source]
sineFunc(x, a1, a2, a3, a4)[source]
squareFit(xReal, yReal)[source]
squareFunc(x, amp, freq, phase, dc, offset)[source]

SEEL.commands_proto module

SEEL.commands_proto.applySIPrefix(value, unit='', precision=2)[source]

SEEL.digital_channel module

class SEEL.digital_channel.digital_channel(a)[source]
DISABLED = 0
EVERY_EDGE = 1
EVERY_FALLING_EDGE = 2
EVERY_FOURTH_RISING_EDGE = 4
EVERY_RISING_EDGE = 3
EVERY_SIXTEENTH_RISING_EDGE = 5
generate_axes()[source]
get_xaxis()[source]
get_yaxis()[source]
load_data(initial_state, timestamps)[source]
set_params(**keys)[source]

SEEL.interface module

class SEEL.interface.Interface(timeout=1.0, **kwargs)[source]

Communications library.

This class contains methods that can be used to interact with the vLabtool

Initialization does the following

  • connects to tty device
  • loads calibration values.
Arguments Description
timeout serial port read timeout. default = 1s
>>> from SEEL import interface
>>> I = interface.connect()
>>> self.__print__(I)
<interface.Interface instance at 0xb6c0cac>

Once you have instantiated this class, its various methods will allow access to all the features built into the device.

ADC_POLYNOMIALS_LOCATION = 3
ADC_SHIFTS_LOCATION1 = 1
ADC_SHIFTS_LOCATION2 = 2
BAUD = 1000000
DAC_SHIFTS_PV1A = 4
DAC_SHIFTS_PV1B = 5
DAC_SHIFTS_PV2A = 6
DAC_SHIFTS_PV2B = 7
DAC_SHIFTS_PV3A = 8
DAC_SHIFTS_PV3B = 9
DutyCycle(channel='ID1', timeout=1.0)[source]

duty cycle measurement on channel

returns wavelength(seconds), and length of first half of pulse(high time)

low time = (wavelength - high time)

Arguments  
channel The input pin to measure wavelength and high time.[‘ID1’,’ID2’,’ID3’,’ID4’,’SEN’,’EXT’,’CNTR’]
timeout
Use the timeout option if you’re unsure of the input signal time period.
returns 0 if timed out

:return : wavelength,duty cycle

See also

timing_example

MeasureInterval(channel1, channel2, edge1, edge2, timeout=0.1)[source]

Measures time intervals between two logic level changes on any two digital inputs(both can be the same)

For example, one can measure the time interval between the occurence of a rising edge on ID1, and a falling edge on ID3. If the returned time is negative, it simply means that the event corresponding to channel2 occurred first.

returns the calculated time

Arguments  
channel1 The input pin to measure first logic level change
channel2
The input pin to measure second logic level change
-[‘ID1’,’ID2’,’ID3’,’ID4’,’SEN’,’EXT’,’CNTR’]
edge1
The type of level change to detect in order to start the timer
  • ‘rising’
  • ‘falling’
  • ‘four rising edges’
edge2
The type of level change to detect in order to stop the timer
  • ‘rising’
  • ‘falling’
  • ‘four rising edges’
timeout
Use the timeout option if you’re unsure of the input signal time period.
returns -1 if timed out

:return : time

See also

timing_example

MeasureMultipleDigitalEdges(channel1, channel2, edgeType1, edgeType2, points1, points2, timeout=0.1, **kwargs)[source]

Measures a set of timestamped logic level changes(Type can be selected) from two different digital inputs.

Example

Aim : Calculate value of gravity using time of flight. The setup involves a small metal nut attached to an electromagnet powered via SQ1. When SQ1 is turned off, the set up is designed to make the nut fall through two different light barriers(LED,detector pairs that show a logic change when an object gets in the middle) placed at known distances from the initial position.

one can measure the timestamps for rising edges on ID1 ,and ID2 to determine the speed, and then obtain value of g

Arguments  
channel1 The input pin to measure first logic level change
channel2
The input pin to measure second logic level change
-[‘ID1’,’ID2’,’ID3’,’ID4’,’SEN’,’EXT’,’CNTR’]
edgeType1
The type of level change that should be recorded
  • ‘rising’
  • ‘falling’
  • ‘four rising edges’ [default]
edgeType2
The type of level change that should be recorded
  • ‘rising’
  • ‘falling’
  • ‘four rising edges’
points1 Number of data points to obtain for input 1 (Max 4)
points2 Number of data points to obtain for input 2 (Max 4)
timeout
Use the timeout option if you’re unsure of the input signal time period.
returns -1 if timed out
**kwargs  
SQ1 set the state of SQR1 output(LOW or HIGH) and then start the timer. eg. SQR1=’LOW’
zero subtract the timestamp of the first point from all the others before returning. default:True

:return : time

See also

timing_example

PulseTime(channel='ID1', PulseType='LOW', timeout=0.1)[source]

duty cycle measurement on channel

returns wavelength(seconds), and length of first half of pulse(high time)

low time = (wavelength - high time)

Arguments  
channel The input pin to measure wavelength and high time.[‘ID1’,’ID2’,’ID3’,’ID4’,’SEN’,’EXT’,’CNTR’]
PulseType Type of pulse to detect. May be ‘HIGH’ or ‘LOW’
timeout
Use the timeout option if you’re unsure of the input signal time period.
returns 0 if timed out

:return : pulse width

See also

timing_example

TemperatureAndHumidity()[source]

init AM2302. This effort was a waste. There are better humidity and temperature sensors available which use well documented I2C

WS2812B(cols, output='CS1')[source]

set shade of WS2182 LED on SQR1

Arguments  
cols
2Darray [[R,G,B],[R2,G2,B2],[R3,G3,B3]...]
brightness of R,G,B ( 0-255 )

example:

>>> I.WS2812B([[10,0,0],[0,10,10],[10,0,10]])
#sets red, cyan, magenta to three daisy chained LEDs

see rgb_video

WType = {'W2': 'sine', 'W1': 'sine'}
capacitance_via_RC_discharge(samples, tg)[source]
capture1(ch, ns, tg, *args)[source]

Blocking call that fetches an oscilloscope trace from the specified input channel

Arguments  
ch Channel to select as input. [‘CH1’..’CH3’,’SEN’]
ns Number of samples to fetch. Maximum 10000
tg Timegap between samples in microseconds
alternate text

A sine wave captured and plotted.

Example

>>> from pylab import *
>>> from SEEL import interface
>>> I=interface.connect()
>>> x,y = I.capture1('CH1',3200,1)
>>> plot(x,y)
>>> show()
Returns:Arrays X(timestamps),Y(Corresponding Voltage values)
capture2(ns, tg, TraceOneRemap='CH1')[source]

Blocking call that fetches oscilloscope traces from CH1,CH2

Arguments  
ns Number of samples to fetch. Maximum 5000
tg Timegap between samples in microseconds
TraceOneRemap Choose the analog input for channel 1. It is connected to CH1 by default. Channel 2 always reads CH2.
alternate text

Two sine waves captured and plotted.

Example

>>> from pylab import *
>>> from SEEL import interface
>>> I=interface.connect()
>>> x,y1,y2 = I.capture2(1600,2,'MIC')  #Chan1 remapped to MIC. Chan2 reads CH2
>>> plot(x,y1)              #Plot of analog input MIC
>>> plot(x,y2)              #plot of analog input CH2
>>> show()              
Returns:Arrays X(timestamps),Y1(Voltage at CH1),Y2(Voltage at CH2)
capture4(ns, tg, TraceOneRemap='CH1')[source]

Blocking call that fetches oscilloscope traces from CH1,CH2,CH3,CH4

Arguments  
ns Number of samples to fetch. Maximum 2500
tg Timegap between samples in microseconds. Minimum 1.75uS
TraceOneRemap Choose the analog input for channel 1. It is connected to CH1 by default. Channel 2 always reads CH2.
alternate text

Four traces captured and plotted.

Example

>>> from pylab import *
>>> I=interface.Interface()
>>> x,y1,y2,y3,y4 = I.capture4(800,1.75)
>>> plot(x,y1)              
>>> plot(x,y2)              
>>> plot(x,y3)              
>>> plot(x,y4)              
>>> show()              
Returns:Arrays X(timestamps),Y1(Voltage at CH1),Y2(Voltage at CH2),Y3(Voltage at CH3),Y4(Voltage at CH4)
capture_edges1(waiting_time=1.0, **args)[source]

log timestamps of rising/falling edges on one digital input

Arguments  
waiting_time
Total time to allow the logic analyzer to collect data.
This is implemented using a simple sleep routine, so if large delays will be involved, refer to start_one_channel_LA() to start the acquisition, and fetch_LA_channels() to retrieve data from the hardware after adequate time. The retrieved data is stored in the array self.dchans[0].timestamps.
keyword arguments  
channel ‘ID1’,...,’ID4’
trigger_channel ‘ID1’,...,’ID4’
channel_mode

acquisition mode

default value: 3

  • EVERY_SIXTEENTH_RISING_EDGE = 5
  • EVERY_FOURTH_RISING_EDGE = 4
  • EVERY_RISING_EDGE = 3
  • EVERY_FALLING_EDGE = 2
  • EVERY_EDGE = 1
  • DISABLED = 0
trigger_mode
same as channel_mode.
default_value : 3
Returns:timestamp array in Seconds
>>> I.capture_edges(0.2,channel='ID1',trigger_channel='ID1',channel_mode=3,trigger_mode = 3)
#captures rising edges only. with rising edge trigger on ID1
capture_fullspeed(chan, samples, tg, *args, **kwargs)[source]

Blocking call that fetches oscilloscope traces from a single oscilloscope channel at a maximum speed of 2MSPS

from pylab import *
I=interface.Interface()
x,y = I.capture_fullspeed('CH1',2000,1)
plot(x,y)               
show()
x,y = I.capture_fullspeed('CH1',2000,1,'SET_LOW')
plot(x,y)               
show()
I.sqr1(40e3 , 50, True )   # Prepare a 40KHz, 50% square wave. Do not output it yet
x,y = I.capture_fullspeed('CH1',2000,1,'FIRE_PULSES',interval = 250) #Output the prepared 40KHz(25uS) wave for 250uS(10 cycles) before acquisition
plot(x,y)               
show()
Returns:timestamp array ,voltage_value array
capture_fullspeed_hr(chan, samples, tg, *args)[source]
capture_highres_traces(channel, samples, tg, **kwargs)[source]

Instruct the ADC to start sampling. use fetch_trace to retrieve the data

Arguments  
channel channel to acquire data from ‘CH1’ ... ‘CH9’
samples Total points to store per channel. Maximum 3200 total.
tg Timegap between two successive samples (in uSec)
**kwargs  
*trigger Whether or not to trigger the oscilloscope based on the voltage level set by configure_trigger()
Returns:nothing
capture_multiple(samples, tg, *args)[source]

Blocking call that fetches oscilloscope traces from a set of specified channels

Arguments  
samples Number of samples to fetch. Maximum 10000/(total specified channels)
tg Timegap between samples in microseconds.
*args channel names

Example

>>> from pylab import *
>>> I=interface.Interface()
>>> x,y1,y2,y3,y4 = I.capture_multiple(800,1.75,'CH1','CH2','MIC','SEN')
>>> plot(x,y1)              
>>> plot(x,y2)              
>>> plot(x,y3)              
>>> plot(x,y4)              
>>> show()              
Returns:Arrays X(timestamps),Y1,Y2 ...
capture_traces(num, samples, tg, channel_one_input='CH1', CH123SA=0, **kwargs)[source]

Instruct the ADC to start sampling. use fetch_trace to retrieve the data

Arguments  
num Channels to acquire. 1/2/4
samples Total points to store per channel. Maximum 3200 total.
tg Timegap between two successive samples (in uSec)
channel_one_input map channel 1 to ‘CH1’ ... ‘CH9’
**kwargs  
*trigger Whether or not to trigger the oscilloscope based on the voltage level set by configure_trigger()

see capture_video

alternate text

Transient response of an Inductor and Capacitor in series

The following example demonstrates how to use this function to record active events.

  • Connect a capacitor and an Inductor in series.
  • Connect CH1 to the spare leg of the inductor. Also Connect OD1 to this point
  • Connect CH2 to the junction between the capacitor and the inductor
  • connect the spare leg of the capacitor to GND( ground )
  • set OD1 initially high using set_state(SQR1=1)
>>> I.set_state(OD1=1)  #Turn on OD1
#Arbitrary delay to wait for stabilization
>>> time.sleep(0.5)                
#Start acquiring data (2 channels,800 samples, 2microsecond intervals)
>>> I.capture_traces(2,800,2,trigger=False)
#Turn off OD1. This must occur immediately after the previous line was executed.
>>> I.set_state(OD1=0)
#Minimum interval to wait for completion of data acquisition.
#samples*timegap*(convert to Seconds)
>>> time.sleep(800*2*1e-6)
>>> x,CH1=I.fetch_trace(1)
>>> x,CH2=I.fetch_trace(2)
>>> plot(x,CH1-CH2) #Voltage across the inductor                
>>> plot(x,CH2)     ##Voltage across the capacitor      
>>> show()              

The following events take place when the above snippet runs

  1. The oscilloscope starts storing voltages present at CH1 and CH2 every 2 microseconds
  2. The output OD1 was enabled, and this causes the voltage between the L and C to approach OD1 voltage. (It may or may not oscillate)
  3. The data from CH1 and CH2 was read into x,CH1,CH2
  4. Both traces were plotted in order to visualize the Transient response of series LC
Returns:nothing
clear_buffer(starting_position, total_points)[source]

clears a section of the ADC hardware buffer

configure_trigger(chan, name, voltage, resolution=10, **kwargs)[source]

configure trigger parameters for 10-bit capture commands The capture routines will wait till a rising edge of the input signal crosses the specified level. The trigger will timeout within 8mS, and capture routines will start regardless.

These settings will not be used if the trigger option in the capture routines are set to False

Arguments  
chan channel . 0, 1,2,3. corresponding to the channels being recorded by the capture routine(not the analog inputs)
name the name of the channel. ‘CH1’... ‘V+’
voltage The voltage level that should trigger the capture sequence(in Volts)

Example

>>> I.configure_trigger(0,'CH1',1.1)
>>> I.capture_traces(4,800,2)
#Unless a timeout occured, the first point of this channel will be close to 1.1Volts
>>> I.fetch_trace(1)
#This channel was acquired simultaneously with channel 1, 
#so it's triggered along with the first
>>> I.fetch_trace(2)
countPulses(channel='SEN')[source]

Count pulses on a digital input. Retrieve total pulses using readPulseCount

Arguments  
channel The input pin to measure rising edges on : [‘ID1’,’ID2’,’ID3’,’ID4’,’SEN’,’EXT’,’CNTR’]
device_id()[source]
enableUartPassthrough(baudrate, persist=False)[source]

All data received by the device is relayed to an external port(SCL[TX],SDA[RX]) after this function is called

If a period > .5 seconds elapses between two transmit/receive events, the device resets and resumes normal mode. This timeout feature has been implemented in lieu of a hard reset option. can be used to load programs into secondary microcontrollers with bootloaders such ATMEGA, and ESP8266

Arguments  
baudrate BAUDRATE to use
persist
If set to True, the device will stay in passthrough mode until the next power cycle.
Otherwise(default scenario), the device will return to normal operation if no data is sent/ received for a period greater than one second at a time.
estimateDistance()[source]

Read data from ultrasonic distance sensor HC-SR04/HC-SR05. Sensors must have separate trigger and output pins. First a 10uS pulse is output on SQR1. SQR1 must be connected to the TRIG pin on the sensor prior to use.

Upon receiving this pulse, the sensor emits a sequence of sound pulses, and the logic level of its output pin(which we will monitor via ID1) is also set high. The logic level goes LOW when the sound packet returns to the sensor, or when a timeout occurs.

The ultrasound sensor outputs a series of 8 sound pulses at 40KHz which corresponds to a time period of 25uS per pulse. These pulses reflect off of the nearest object in front of the sensor, and return to it. The time between sending and receiving of the pulse packet is used to estimate the distance. If the reflecting object is either too far away or absorbs sound, less than 8 pulses may be received, and this can cause a measurement error of 25uS which corresponds to 8mm.

Ensure 5V supply.

returns 0 upon timeout

f2f_time(channel, skip_cycle=0, timeout=5)[source]

Return a list of falling edges that occured within the timeout period.

Arguments  
channel The input to measure time between two falling edges.[‘ID1’,’ID2’,’ID3’,’ID4’,’SEN’,’EXT’,’CNTR’]
skip_cycle Number of points to skip. eg. Pendulums pass through light barriers twice every cycle. SO 1 must be skipped
timeout Number of seconds to wait for datapoints. (Maximum 60 seconds)
Return list:Array of points
fetch_LA_channels(trigchan=1)[source]

reads and stores the channels in self.dchans.

Arguments  
trigchan:
channel number which should be treated as a trigger. (1,2,3,4). Its first timestamp
is subtracted from the rest of the channels.
fetch_buffer(starting_position=0, total_points=100)[source]

fetches a section of the ADC hardware buffer

fetch_int_data_from_LA(bytes, chan=1)[source]

fetches the data stored by DMA. integer address increments

Arguments  
bytes: number of readings(integers) to fetch
chan: channel number (1-4)
fetch_long_data_from_LA(bytes, chan=1)[source]

fetches the data stored by DMA. long address increments

Arguments  
bytes: number of readings(long integers) to fetch
chan: channel number (1,2)
fetch_trace(channel_number)[source]

fetches a channel(1-4) captured by capture_traces() called prior to this, and returns xaxis,yaxis

Arguments  
channel_number Any of the maximum of four channels that the oscilloscope captured. 1/2/3/4
Returns:time array,voltage array
fill_buffer(starting_position, point_array)[source]

fill a section of the ADC hardware buffer with data

get_LA_initial_states()[source]

fetches the initial states of digital inputs that were recorded right before the Logic analyzer was started, and the total points each channel recorded

Returns:chan1 progress,chan2 progress,chan3 progress,chan4 progress,[ID1,ID2,ID3,ID4]. eg. [1,0,1,1]
get_average_voltage(channel_name, **kwargs)[source]

Return the voltage on the selected channel

Arguments Description
channel_name ‘CH1’,’CH2’,’CH3’, ‘MIC’,’IN1’,’SEN’,’V+’
sleep read voltage in CPU sleep mode. not particularly useful. Also, Buggy.
**kwargs Samples to average can be specified. eg. samples=100 will average a hundred readings

see stream_video

Example:

>>> self.__print__(I.get_average_voltage('CH4'))
1.002
get_capacitance()[source]

measures capacitance of component connected between IN1 and ground

Returns:Capacitance (F)

Constant Current Charging

\[Q_{stored} = C*V\]\[I_{constant}*time = C*V\]\[C = I_{constant}*time/V_{measured}\]

Also uses Constant Voltage Charging via 20K resistor if required.

get_capacitor_range()[source]

Charges a capacitor connected to IN1 via a 20K resistor from a 3.3V source for a fixed interval Returns the capacitance calculated using the formula Vc = Vs(1-exp(-t/RC)) This function allows an estimation of the parameters to be used with the get_capacitance() function.

get_ctmu_voltage(channel, Crange, tgen=1)[source]

get_ctmu_voltage(5,2) will activate a constant current source of 5.5uA on IN1 and then measure the voltage at the output. If a diode is used to connect IN1 to ground, the forward voltage drop of the diode will be returned. e.g. .6V for a 4148diode.

If a resistor is connected, ohm’s law will be followed within reasonable limits

channel=5 for IN1

CRange=0 implies 550uA CRange=1 implies 0.55uA CRange=2 implies 5.5uA CRange=3 implies 55uA

Returns:Voltage
get_freq(channel='CNTR', timeout=0.1)[source]

Frequency measurement on IDx. Measures time taken for 16 rising edges of input signal. returns the frequency in Hertz

Arguments  
channel The input to measure frequency from. [‘ID1’,’ID2’,’ID3’,’ID4’,’SEN’,’EXT’,’CNTR’]
timeout
This is a blocking call which will wait for one full wavelength before returning the
calculated frequency. Use the timeout option if you’re unsure of the input signal. returns 0 if timed out
Return float:frequency
  • connect SQR1 to ID1
>>> I.sqr1(4000,25)
>>> self.__print__(I.get_freq('ID1'))
4000.0
>>> self.__print__(I.r2r_time('ID1'))
#time between successive rising edges
0.00025
>>> self.__print__(I.f2f_time('ID1'))
#time between successive falling edges
0.00025
>>> self.__print__(I.pulse_time('ID1'))
#may detect a low pulse, or a high pulse. Whichever comes first
6.25e-05
>>> I.duty_cycle('ID1')
#returns wavelength, high time
(0.00025,6.25e-05)          
get_high_freq(pin)[source]

experimental feature. Attempt to use fewer timers

get_state(input_id)[source]

returns the logic level on the specified input (ID1,ID2,ID3, or ID4)

Arguments Description
input_id
the input channel
‘ID1’ -> state of ID1 ‘ID4’ -> state of ID4
>>> self.__print__(I.get_state(I.ID1))
False
get_states()[source]

gets the state of the digital inputs. returns dictionary with keys ‘ID1’,’ID2’,’ID3’,’ID4’

>>> self.__print__(get_states())
{'ID1': True, 'ID2': True, 'ID3': True, 'ID4': False}
get_temperature()[source]

return the processor’s temperature

Returns:Chip Temperature in degree Celcius
get_version()[source]

Returns the version string of the device format: LTS-......

get_voltage(channel_name, **kwargs)[source]
load_equation(chan, function, span=None)[source]

Load an arbitrary waveform to the waveform generators

Arguments  
chan The waveform generator to alter. W1 or W2
function A function that will be used to generate the datapoints
span the range of values in which to evaluate the given function
fn = lambda x:abs(x-50)  #Triangular waveform 
self.I.load_waveform('W1',fn,[0,100])
#Load triangular wave to wavegen 1

#Load sinusoidal wave to wavegen 2
self.I.load_waveform('W2',np.sin,[0,2*np.pi])
load_table(chan, points, mode='arbit')[source]

Load an arbitrary waveform table to the waveform generators

Arguments  
chan The waveform generator to alter. ‘W1’ or ‘W2’
points A list of 512 datapoints exactly
mode Optional argument. Type of waveform. default value ‘arbit’. accepts ‘sine’, ‘tria’

example:

>>> self.I.load_waveform_table(1,range(512))
#Load sawtooth wave to wavegen 1
map_reference_clock(scaler, *args)[source]

Map the internal oscillator output to SQR1,SQR2,SQR3,SQR4 or WAVEGEN The output frequency is 128/(1<<scaler) MHz

scaler [0-15]

  • 0 -> 128MHz
  • 1 -> 64MHz
  • 2 -> 32MHz
  • 3 -> 16MHz
  • .
  • .
  • 15 ->128./32768 MHz

example:

>>> I.map_reference_clock(2,'SQR1','SQR2')

outputs 32 MHz on SQR1, SQR2 pins

Note

if you change the reference clock for ‘wavegen’ , the waveform generator resolution and range will also change. default frequency for ‘wavegen’ is 16MHz. Setting to 1MHz will give you 16 times better resolution, but a usable range of 0Hz to about 100KHz instead of the original 2MHz.

Arguments Description
**Kwargs Keyword Arguments
address

Address of the node. a 24 bit number. Printed on the nodes.

can also be retrieved using get_nodelist()
Returns:RadioLink()
opticalArray(tg, delay, tp)[source]

read from 3648 element optical sensor array TCD3648P from Toshiba

see tcd_video

oscilloscope_progress()[source]

returns the number of samples acquired by the capture routines, and the conversion_done status

Returns:conversion done(bool) ,samples acquired (number)
>>> I.start_capture(1,3200,2)
>>> self.__print__(I.oscilloscope_progress())
(0,46)
>>> time.sleep(3200*2e-6)
>>> self.__print__(I.oscilloscope_progress())
(1,3200)
r2r_time(channel, skip_cycle=0, timeout=5)[source]

Return a list of rising edges that occured within the timeout period.

Arguments  
channel The input to measure time between two rising edges.[‘ID1’,’ID2’,’ID3’,’ID4’,’SEN’,’EXT’,’CNTR’]
skip_cycle Number of points to skip. eg. Pendulums pass through light barriers twice every cycle. SO 1 must be skipped
timeout Number of seconds to wait for datapoints. (Maximum 60 seconds)
Return list:Array of points
readLog()[source]

read hardware debug log.

readPulseCount()[source]

Read pulses counted using a digital input. Call countPulses before using this.

Arguments  
   
readUART2()[source]
readUART2Status()[source]
read_bulk_flash(page, bytes)[source]

Reads BYTES from the specified location

Arguments  
page Block number. 0-20. each block is 2kB.
bytes Total bytes to read
Returns:a string of 16 characters read from the location
read_data_address(address)[source]

Reads and returns the value stored at the specified address in RAM

Arguments  
address Address to read from. Refer to PIC24EP64GP204 programming manual|
read_flash(page, location)[source]

Reads 16 BYTES from the specified location

Arguments  
page page number. 20 pages with 2KBytes each
location The flash location(0 to 63) to read from .
Returns:a string of 16 characters read from the location
read_program_address(address)[source]

Reads and returns the value stored at the specified address in program memory

Arguments  
address Address to read from. Refer to PIC24EP64GP204 programming manual
reconnect(**kwargs)[source]

Attempts to reconnect to the device in case of a commmunication error or accidental disconnect.

resetHardware()[source]

Resets the device, and standalone mode will be enabled if an OLED is connected to the I2C port

restoreStandalone()[source]

Resets the device, and standalone mode will be enabled if an OLED is connected to the I2C port

servo(chan, angle)[source]

Output A PWM waveform on SQR1/SQR2 corresponding to the angle specified in the arguments. This is used to operate servo motors. Tested with 9G SG-90 Servo motor.

Arguments  
chan 1 or 2. Whether to use SQ1 or SQ2 to output the PWM waveform used by the servo
angle 0-180. Angle corresponding to which the PWM waveform is generated.
servo4(a1, a2, a3, a4)[source]

Operate Four servo motors independently using SQR1, SQR2, SQR3, SQR4. tested with SG-90 9G servos.

Arguments  
a1 Angle to set on Servo which uses SQR1 as PWM input. [0-180]
a2 Angle to set on Servo which uses SQR2 as PWM input. [0-180]
a3 Angle to set on Servo which uses SQR3 as PWM input. [0-180]
a4 Angle to set on Servo which uses SQR4 as PWM input. [0-180]
setOnboardLED(R, G, B)[source]

set shade of WS2182 LED on PIC1572 1 RA2

Arguments  
R brightness of red colour 0-255
G brightness of green colour 0-255
B brightness of blue colour 0-255
setUART2(BAUD)[source]
set_gain(channel, gain)[source]

set the gain of the selected PGA

Arguments  
channel ‘CH1’,’CH2’
gain (0-7) -> (1x,2x,4x,5x,8x,10x,16x,32x)

Note

The gain value applied to a channel will result in better resolution for small amplitude signals.

However, values read using functions like get_average_voltage() or capture_traces() will not be 2x, or 4x times the input signal. These are calibrated to return accurate values of the original input signal.

>>> I.set_gain('CH1',7)  #gain set to 32x on CH1
set_pcs(val)[source]

Set programmable current source

Arguments  
val Output current on PCS. 0 to 3.3mA. Subject to load resistance. Read voltage on PCS to check.
Returns:value attempted to set on pcs
set_pv1(val)[source]

Set the voltage on PV1 12-bit DAC... -5V to 5V

Arguments  
val Output voltage on PV1. -5V to 5V
set_pv2(val)[source]

Set the voltage on PV2. 12-bit DAC... 0-3.3V

Arguments  
val Output voltage on PV2. 0-3.3V
Returns:Actual value set on pv2
set_pv3(val)[source]

Set the voltage on PV3

Arguments  
val Output voltage on PV3. 0V to 3.3V
Returns:Actual value set on pv3
set_sine1(freq)[source]

Set the frequency of wavegen 1 after setting its waveform type to sinusoidal

Arguments  
frequency Frequency to set on wave generator 1.
Returns:frequency
set_sine2(freq)[source]

Set the frequency of wavegen 2 after setting its waveform type to sinusoidal

Arguments  
frequency Frequency to set on wave generator 1.
Returns:frequency
set_sqrs(wavelength, phase, high_time1, high_time2, prescaler=1)[source]

Set the frequency of sqr1,sqr2, with phase shift

Arguments  
wavelength Number of 64Mhz/prescaler clock cycles per wave
phase Clock cycles between rising edges of SQR1 and SQR2
high time1 Clock cycles for which SQR1 must be HIGH
high time2 Clock cycles for which SQR2 must be HIGH
prescaler 0,1,2. Divides the 64Mhz clock by 8,64, or 256
set_state(**kwargs)[source]

set the logic level on digital outputs SQR1,SQR2,SQR3,SQR4

Arguments  
**kwargs
SQR1,SQR2,SQR3,SQR4
states(0 or 1)
>>> I.set_state(SQR1=1,SQR2=0)
sets SQR1 HIGH, SQR2 LOw, but leave SQR3,SQR4 untouched.
set_w1(freq, waveType=None)[source]

Set the frequency of wavegen 1

Arguments  
frequency Frequency to set on wave generator 1.
Returns:frequency
set_w2(freq, waveType=None)[source]

Set the frequency of wavegen 2

Arguments  
frequency Frequency to set on wave generator 1.
Returns:frequency
set_wave(chan, freq)[source]

Set the frequency of wavegen

Arguments  
chan Channel to set frequency for. W1 or W2
frequency Frequency to set on wave generator
Returns:frequency
set_waves(freq, phase, f2=None)[source]

Set the frequency of wavegen

Arguments  
frequency Frequency to set on both wave generators
phase Phase difference between the two. 0-360 degrees
f2 Only specify if you require two separate frequencies to be set
Returns:frequency
sqr1(freq, duty_cycle=50, onlyPrepare=False)[source]

Set the frequency of sqr1

Arguments  
frequency Frequency
duty_cycle Percentage of high time
sqr1_pattern(timing_array)[source]

output a preset sqr1 frequency in fixed intervals. Can be used for sending IR signals that are packets of 38KHz pulses. refer to the example

Arguments  
timing_array A list of on & off times in uS units
sqr2(freq, duty_cycle)[source]

Set the frequency of sqr2

Arguments  
frequency Frequency
duty_cycle Percentage of high time
sqr4_continuous(freq, h0, p1, h1, p2, h2, p3, h3, **kwargs)[source]

Initialize continuously running phase correlated square waves on SQR1,SQR2,OD1,OD2

Arguments  
freq Frequency in Hertz
h0 Duty Cycle for SQR1 (0-1)
p1 Phase shift for SQR2 (0-1)
h1 Duty Cycle for SQR2 (0-1)
p2 Phase shift for OD1 (0-1)
h2 Duty Cycle for OD1 (0-1)
p3 Phase shift for OD2 (0-1)
h3 Duty Cycle for OD2 (0-1)
start_four_channel_LA(trigger=1, maximum_time=0.001, mode=[1, 1, 1, 1], **args)[source]

Four channel Logic Analyzer. start logging timestamps from a 64MHz counter to record level changes on ID1,ID2,ID3,ID4.

Arguments  
trigger Bool . Enable rising edge trigger on ID1
maximum_time

Maximum delay expected between two logic level changes.

If total time exceeds 1 mS, a prescaler will be used in the reference clock However, this only refers to the maximum time between two successive level changes. If a delay larger than .26 S occurs, it will be truncated by modulo .26 S.

If you need to record large intervals, try single channel/two channel modes which use 32 bit counters capable of time interval up to 67 seconds.

mode

modes for each channel. List with four elements

default values: [1,1,1,1]

  • EVERY_SIXTEENTH_RISING_EDGE = 5
  • EVERY_FOURTH_RISING_EDGE = 4
  • EVERY_RISING_EDGE = 3
  • EVERY_FALLING_EDGE = 2
  • EVERY_EDGE = 1
  • DISABLED = 0
Returns:Nothing

See also

Use fetch_long_data_from_LA() (points to read,x) to get data acquired from channel x. The read data can be accessed from dchans [x-1]

start_one_channel_LA(**args)[source]

start logging timestamps of rising/falling edges on ID1

Arguments  
args  
channel [‘ID1’,’ID2’,’ID3’,’ID4’,’SEN’,’EXT’,’CNTR’]
trigger_channel [‘ID1’,’ID2’,’ID3’,’ID4’,’SEN’,’EXT’,’CNTR’]
channel_mode
acquisition mode.

default value: 1

  • EVERY_SIXTEENTH_RISING_EDGE = 5
  • EVERY_FOURTH_RISING_EDGE = 4
  • EVERY_RISING_EDGE = 3
  • EVERY_FALLING_EDGE = 2
  • EVERY_EDGE = 1
  • DISABLED = 0
trigger_mode
same as channel_mode.
default_value : 3
Returns:Nothing

see LA_video

start_one_channel_LA_backup__(trigger=1, channel='ID1', maximum_time=67, **args)[source]

start logging timestamps of rising/falling edges on ID1

Arguments  
trigger Bool . Enable edge trigger on ID1. use keyword argument edge=’rising’ or ‘falling’
channel [‘ID1’,’ID2’,’ID3’,’ID4’,’SEN’,’EXT’,’CNTR’]
maximum_time Total time to sample. If total time exceeds 67 seconds, a prescaler will be used in the reference clock
kwargs  
triggger_channels
array of digital input names that can trigger the acquisition.eg. trigger= [‘ID1’,’ID2’,’ID3’]
will triggger when a logic change specified by the keyword argument ‘edge’ occurs on either or the three specified trigger inputs.
edge ‘rising’ or ‘falling’ . trigger edge type for trigger_channels.
Returns:Nothing
start_streaming(tg, channel='CH1')[source]

Instruct the ADC to start streaming 8-bit data. use stop_streaming to stop.

Arguments  
tg timegap. 250KHz clock
channel channel ‘CH1’... ‘CH9’,’IN1’,’SEN’
start_three_channel_LA(**args)[source]

start logging timestamps of rising/falling edges on ID1,ID2,ID3

Arguments  
args  
trigger_channel [‘ID1’,’ID2’,’ID3’,’ID4’,’SEN’,’EXT’,’CNTR’]
modes

modes for each channel. Array .

default value: [1,1,1]

  • EVERY_SIXTEENTH_RISING_EDGE = 5
  • EVERY_FOURTH_RISING_EDGE = 4
  • EVERY_RISING_EDGE = 3
  • EVERY_FALLING_EDGE = 2
  • EVERY_EDGE = 1
  • DISABLED = 0
trigger_mode
same as modes(previously documented keyword argument)
default_value : 3
Returns:Nothing
start_two_channel_LA(trigger=1, maximum_time=67)[source]

start logging timestamps of rising/falling edges on ID1,AD2

Arguments  
trigger Bool . Enable rising edge trigger on ID1
maximum_time Total time to sample. If total time exceeds 67 seconds, a prescaler will be used in the reference clock
"fetch_long_data_from_dma(samples,1)" to get data acquired from channel 1
"fetch_long_data_from_dma(samples,2)" to get data acquired from channel 2
The read data can be accessed from self.dchans[0 or 1]
stepBackward(steps, delay)[source]

Control stepper motors using SQR1-4

take a fixed number of steps in the backward direction with a certain delay( in milliseconds ) between each step.

stepForward(steps, delay)[source]

Control stepper motors using SQR1-4

take a fixed number of steps in the forward direction with a certain delay( in milliseconds ) between each step.

stop_LA()[source]

Stop any running logic analyzer function

stop_streaming()[source]

Instruct the ADC to stop streaming data

writeUART2(character)[source]
write_bulk_flash(location, data)[source]

write a byte array to the entire flash page. Erases any other data

DO NOT USE THIS UNLESS YOU’RE ABSOLUTELY SURE YOU KNOW THIS! YOU MAY END UP OVERWRITING THE CALIBRATION DATA, AND WILL HAVE TO GO THROUGH THE TROUBLE OF GETTING IT FROM THE MANUFACTURER AND REFLASHING IT.

Arguments  
location Block number. 0-20. each block is 2kB.
bytearray Array to dump onto flash. Max size 2048 bytes
write_data_address(address, value)[source]

Writes a value to the specified address in RAM

Arguments  
address Address to write to. Refer to PIC24EP64GP204 programming manual|
write_flash(page, location, string_to_write)[source]

write a 16 BYTE string to the selected location (0-63)

DO NOT USE THIS UNLESS YOU’RE ABSOLUTELY SURE KNOW THIS! YOU MAY END UP OVERWRITING THE CALIBRATION DATA, AND WILL HAVE TO GO THROUGH THE TROUBLE OF GETTING IT FROM THE MANUFACTURER AND REFLASHING IT.

Arguments  
page page number. 20 pages with 2KBytes each
location The flash location(0 to 63) to write to.
string_to_write a string of 16 characters can be written to each location
SEEL.interface.connect(**kwargs)[source]

If hardware is found, returns an instance of ‘Interface’, else returns None.

SEEL.packet_handler module

class SEEL.packet_handler.Handler(timeout=1.0, **kwargs)[source]
connectToPort(portname)[source]
get_version(fd)[source]
reconnect(**kwargs)[source]
sendBurst()[source]

Transmits the commands stored in the burstBuffer. empties input buffer empties the burstBuffer.

The following example initiates the capture routine and sets OD1 HIGH immediately.

It is used by the Transient response experiment where the input needs to be toggled soon after the oscilloscope has been started.

>>> I.loadBurst=True
>>> I.capture_traces(4,800,2)
>>> I.set_state(I.OD1,I.HIGH)
>>> I.sendBurst()
waitForData(timeout=0.2)[source]
SEEL.packet_handler.timeit(arg='')[source]

SEEL.sensorlist module

Module contents