Bases: object
Communications library.
This class contains methods that can be used to interact with the hardware.
Initialization does the following
Arguments | Description |
---|---|
timeout | serial port read timeout. default = 1s |
>>> I = Interface(2.0)
>>> 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.
Sub-Instance I2C of the Interface library contains methods to access devices connected to the I2C port.
>>> I.I2C.start(self.ADDRESS,0) #writing mode
>>> I.I2C.send(0x01)
>>> I.I2C.stop()
See also
I2C for complete documentation
Sub-Instance SPI of the Interface library contains methods to access devices connected to the SPI port.
>>> I=Interface()
>>> I.SPI.start('CS1')
>>> I.SPI.send16(0xAAFF)
>>> print I.SPI.send16(0xFFFF)
some number
See also
SPI for complete documentation
Blocking call that fetches an oscilloscope trace from the specified input channel
Arguments | |
---|---|
ch | Channel to select as input. [‘CH1’..’CH9’,‘5V’,’PCS’,‘9V’,’IN1’,’SEN’] |
ns | Number of samples to fetch. Maximum 3200 |
tg | Timegap between samples in microseconds |
Example
>>> from pylab import *
>>> I=interface.Interface()
>>> x,y = I.capture1('CH1',3200,1)
>>> plot(x,y)
>>> show()
Returns: | Arrays X(timestamps),Y(Corresponding Voltage values) |
---|
Blocking call that fetches oscilloscope traces from CH1,CH2
Arguments | |
---|---|
ns | Number of samples to fetch. Maximum 1600 |
tg | Timegap between samples in microseconds |
Example
>>> from pylab import *
>>> I=interface.Interface()
>>> x,y1,y2 = I.capture2(1600,1.25)
>>> plot(x,y1)
>>> plot(x,y2)
>>> show()
Returns: | Arrays X(timestamps),Y1(Voltage at CH1),Y2(Voltage at CH2) |
---|
Blocking call that fetches oscilloscope traces from CH1,CH2,CH3,CH4
Arguments | |
---|---|
ns | Number of samples to fetch. Maximum 800 |
tg | Timegap between samples in microseconds. Minimum 1.75uS |
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) |
---|
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 | |
|
Whether or not to trigger the oscilloscope based on the voltage level set by configure_trigger |
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(OD1=1)
>>> I.set_state(OD1=1) #Turn on OD1 >>> time.sleep(0.5) #Arbitrary delay to wait for stabilization>>> I.capture_traces(2,800,2,trigger=False) #Start acquiring data (2 channels,800 samples, 2microsecond intervals) >>> I.set_state(OD1=0) #Turn off OD1. This must occur immediately after the previous line was executed. >>> time.sleep(800*2*1e-6) #Minimum interval to wait for completion of data acquisition. samples*timegap*(convert to Seconds) >>> 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
- The oscilloscope starts storing voltages present at CH1 and CH2 every 2 microseconds
- The output OD1 was enabled, and this causes the voltages across the L and C to fluctuate
- The data from CH1 and CH2 was read into x,CH1,CH2
- Both traces were plotted in order to visualize the Transient response of series LC
Returns: | nothing |
---|
See also
fetch_trace , osciloscope_progress , capture1 , capture2 , capture4
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 |
---|
See also
capture_traces , osciloscope_progress
returns the number of samples acquired by the capture routines, and the conversion_done status
Returns: | conversion done,samples acquired |
---|
>>> I.start_capture(1,3200,2)
>>> print I.osciloscope_progress()
(0,46)
>>> time.sleep(3200*2e-6)
>>> print I.osciloscope_progress()
(1,3200)
See also
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 or 3 corresponding to the channels being recorded by the capture routines |
level | The voltage level that should trigger the capture sequence(in Volts) |
Example
>>> I.configure_trigger(0,1.1)
>>> I.capture_traces(4,800,2)
>>> I.fetch_trace(1) #Unless a timeout occured, the first point of this channel will be close to 1.1Volts
>>> I.fetch_trace(2) #This channel was acquired simultaneously with channel 1, so it's triggered along with the first
See also
set the gain of the selected PGA
Arguments | |
---|---|
channel | ‘CH1’,’CH2’,’CH3’,’CH4’,’CH5’,’CH6’,’CH7’,’CH8’,’CH9’,‘5V’,’PCS’,‘9V’ |
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
writes a value(12 bit) to the DAC.
Arguments | Description |
---|---|
channel | channel number.
|
n | value to set (0-4095) |
Returns: | nothing |
---|
Warning
n should be between 0 and 4095 for both channels. The output voltage will be scaled accordingly.
>>> I.write_dac(0,4095) # pvs1 set to 5Volts
>>> I.write_dac(0,4095) # pvs1 set to -5Volts
Return the voltage on the selected channel
Arguments | Description |
---|---|
channel_name | ‘CH1’,’CH2’,’CH3’,’CH4’,’CH5’,’CH6’,’CH7’,’CH8’,’CH9’,‘5V’,’PCS’,‘9V’,’IN1’,’SEN’,’TEMP’ |
sleep | read voltage in CPU sleep mode. not particularly useful. |
Example:
>>> print I.get_average_voltage('CH4')
0.002
retrieves the frequency of the signal connected to ID1. >10MHz also good for lower frequencies, but avoid using it since the ADC cannot be used simultaneously. It shares a TIMER with the ADC.
The input frequency is fed to a 32 bit counter for a period of 100mS. The value of the counter at the end of 100mS is used to calculate the frequency.
See also
Arguments | |
---|---|
pin | The input pin to measure frequency from. ‘ID1’ , ‘ID2’, ‘ID3’, ‘ID4’, ‘LMETER’,’CH4’ |
Returns: | frequency |
---|
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’, ‘LMETER’,’CH4’ |
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.set_sqr1(2000,500,1) # TODO: edit this function >>> print I.get_freq('ID1') 4000.0 >>> print I.r2r_time('ID1') #time between successive rising edges 0.00025 >>> print I.f2f_time('ID1') #time between successive falling edges 0.00025 >>> 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)
Returns the time interval between two rising edges of input signal on ID1
Arguments | |
---|---|
channel | The input to measure time between two rising edges.’ID1’ , ‘ID2’, ‘ID3’, ‘ID4’, ‘LMETER’,’CH4’ |
timeout | Use the timeout option if you’re unsure of the input signal time period. returns 0 if timed out |
Return float: | time between two rising edges of input signal |
---|
See also
Returns the time interval between two falling edges of input signal on ID1
Arguments | |
---|---|
channel | The input to measure time between two falling edges. ‘ID1’ , ‘ID2’, ‘ID3’, ‘ID4’, ‘LMETER’,’CH4’ |
timeout | Use the timeout option if you’re unsure of the input signal time period. returns 0 if timed out |
Return float: | time between two falling edges of input signal |
---|
See also
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’, ‘LMETER’,’CH4’ |
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
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 |
channel1 |
|
edge1 |
|
edge2 |
|
timeout | Use the timeout option if you’re unsure of the input signal time period. returns -1 if timed out |
:return : time
See also
pulse time measurement on ID1 returns pulse length(s) of high pulse or low pulse. whichever occurs first
Arguments | |
---|---|
channel |
|
timeout |
|
Return float: | pulse width in seconds |
---|
See also
setup the voltage level and filtering on the analog comparator linked to CH4. It can then be used to directly estimate the frequency and other timing details of input analog waveforms on CH4
Arguments | |
---|---|
level | voltage level for + reference of comparator [0-15] |
digital_filter | Level changes faster than 3 * cpu freq / (1<<digital_filter) will be ignored |
See also
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’,...’LMETER’,’CH4’ |
maximum_time | Total time to sample. If total time exceeds 67 seconds, a prescaler will be used in the reference clock |
Returns: | Nothing |
---|
"fetch_long_data_from_dma(total,1)" to retrieve data
The read data can be accessed from self.dchans
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(points to read,1)" to get data acquired from channel 1
"fetch_long_data_from_dma(points to read,2)" to get data acquired from channel 2
The read data can be accessed from self.dchans[0 or 1]
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. Array 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]
fetches the initial states before the logic analyser started
Returns: | chan1 progress,chan2 progress,chan3 progress,chan4 progress,[ID1,ID2,ID3,ID4]. eg. [1,0,1,1] |
---|
fetches the data stored by DMA. integer address increments
Arguments | |
---|---|
bytes: | number of readings(integers) to fetch |
chan: | channel number (1-4) |
fetches the data stored by DMA. long address increments
Arguments | |
---|---|
bytes: | number of readings(long integers) to fetch |
chan: | channel number (1,2) |
reads and stores the channels in self.dchans.
Arguments | |
---|---|
trigchan: |
|
gets the state of the digital inputs. returns dictionary with keys ‘ID1’,’ID2’,’ID3’,’ID4’
>>> print get_states()
{'ID1': True, 'ID2': True, 'ID3': True, 'ID4': False}
returns the logic level on the specified input (ID1,ID2,ID3, or ID4)
Arguments | Description |
---|---|
input_id | the input channel
|
>>> print I.get_state(I.ID1)
False
set the logic level on digital outputs OD1,OD2,SQR1,SQR2
Arguments | |
---|---|
**kwargs |
|
>>> I.get_state(OD1=1,OD2=0,SQR1=1,SQR2=0)
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.
measures capacitance of component connected between IN1 and ground
Warning
Non standard arguments! Needs to be rewritten
Parameters: |
|
---|---|
Returns: | Voltage,Charging current used,Charging time, Capacitance |
measure the value of the inductor connected to the Inductance measurement unit
Returns: | inductance |
---|
Reads 16 BYTES from the specified location
Arguments | |
---|---|
location | The flash location(0 to 63) to read from . |
Returns: | a string of 16 characters read from the location |
---|
Reads BYTES from the specified location
Arguments | |
---|---|
bytes | Total bytes to read |
Returns: | a string of 16 characters read from the location |
---|
write a 16 BYTE string to the selected location (0-63)
Arguments | |
---|---|
location | The flash location(0 to 63) to write to. |
string_to_write | a string of 16 characters can be written to each location |
write a byte array to the entire flash page. Erases any other data
Arguments | |
---|---|
bytearray | Array to dump onto flash. Max size 1024 bytes |
Outputs an address through the second UART This is used to select which PIC1572 will listen to incoming data
Arguments | |
---|---|
address | slave device address |
Returns: | nothing |
---|
Set the frequency of sine 1
Arguments | |
---|---|
frequency | Frequency to set on wave generator #1 0MHz to 8MHz |
register | Frequency register to update. The wavegen has two different registers for storing the output frequency. These are used to quickly switch between the two registers for applications like frequency shift keying(FSK) |
Returns: | frequency |
---|
Set the frequency of sine 2
Arguments | |
---|---|
frequency | Frequency to set on wave generator #1 0MHz to 8MHz |
register | Frequency register to update. The wavegen has two different registers for storing the output frequency. These are used to quickly switch between the two registers for applications like frequency shift keying(FSK) |
Returns: | frequency |
---|
Set the phase difference between WG1 and WG2
Arguments | |
---|---|
phase | Phase difference between WG1 and WG2 0-360 |
set shade of WS2182 LED on PIC1572 1 RA2
Note
This function normalizes and shifts the input table to the full voltage scale of the wavegen
Arguments | |
---|---|
Channel | Channel number. 1/2 for Sine1 or Sine2 |
expr | A mathematical expression for the waveform. Supports sin,cos,tan,exp |
Set the voltage on PVS1 12-bit DAC... -5V to 5V
Arguments | |
---|---|
val | Output voltage on PVS1. -5V to 5V |
Set the voltage on PVS2. Unbuffered for improved stability 12-bit DAC... -0 - 3.3V
Arguments | |
---|---|
val | Output voltage on PVS2. 0-3.3V |
Set the voltage on PVS3 5-bit DAC... -3V to 3V
Arguments | |
---|---|
val | Output voltage on PVS3. -3.3V to 3.3V |
Returns: | Actual value set on pvs3 |
---|
Set programmable current source 5-bit DAC... 0-3.3mA
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 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 |
set shade of WS2182 LED on SQR1
Arguments | |
---|---|
col | array [R,G,B] |
R | brightness of red colour 0-255 |
G | brightness of green colour 0-255 |
B | brightness of blue colour 0-255 |
Tune the oscillator frequency of PIC1572 (1). 100000->111111 : no change to minimum 000001->011111 : - to maximum
Arguments | |
---|---|
tune | change in clock frequency. -32 to 31 |
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’ |
Set the frequency of sqr1
Arguments | |
---|---|
frequency | Frequency |
duty_cycle | Percentage of high time |
Set the frequency of sqr2
Arguments | |
---|---|
frequency | Frequency |
duty_cycle | Percentage of high time |
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 |
Output one set of phase correlated square pulses 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) |
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) |
Map the internal oscillator output to SQR1,SQR2,OD1 or OD2 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
Reads and returns the value stored at the specified address in program memory
Arguments | |
---|---|
address | Address to read from. Refer to PIC24EP64GP204 programming manual |
Reads and returns the value stored at the specified address in RAM
Arguments | |
---|---|
address | Address to read from. Refer to PIC24EP64GP204 programming manual| |
Writes a value to the specified address in RAM
Arguments | |
---|---|
address | Address to write to. Refer to PIC24EP64GP204 programming manual| |
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. |
Operate Four servo motors independently using SQR1, SQR2, OD1, OD2. 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 OD1 as PWM input. [0-180] |
a4 | Angle to set on Servo which uses OD2 as PWM input. [0-180] |
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 | BAUD9600... BAUD1000000 |
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 OD1. Therefore OD1 must be connected to the TRIG pin on the sensor prior to use.
The sensor then outputs an electrical pulse whose width is equal to the time taken by the sound pulse to return to the source. Therefore its output pin must be connected to ID1 prior to usage.
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.