def parse_arguments(args):
try:
if args.uri == 'auto':
ctx = libm2k.m2kOpen()
else:
ctx = libm2k.m2kOpen(args.uri)
if ctx is None:
raise Exception('Invalid uri')
print('Connection established')
def signal_handler(sig, frame):
nonlocal calibration_values
write_in_file(calibration_values, args.values, args.file)
libm2k.contextClose(ctx)
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
calibration_values = dict()
generate_file(ctx, calibration_values, args.temperature, args.timeout, args.values, args.file, args.append)
libm2k.contextClose(ctx)
return 0
except Exception as error:
print(error)
return -1
def open_context():
"""Opens the context and retrieves analog objects
Returns:
ctx-- M2k context opened
ain-- AnalogIn object
aout--Analog Out object
trig--Trigger object
"""
ctx = libm2k.m2kOpen("ip:192.168.2.1")
if ctx is None:
print(
"Connection Error: No ADALM2000 device available/connected to your PC."
)
exit(1)
#define input and output
try:
ain = ctx.getAnalogIn()
except:
ain = 0
try:
aout = ctx.getAnalogOut()
except:
aout = 0
#define trigger
try:
trig = ain.getTrigger()
except:
trig = 0
return ctx, ain, aout, trig
def main():
context = libm2k.m2kOpen()
if context is None:
print(
"Connection Error: No ADALM2000 device available/connected to your PC."
)
exit(1)
# check if mixed signal is available on your firmware version
if context.hasMixedSignal() is False:
print("Mixed Signal not available")
exit(1)
context.calibrateDAC()
analog_in = context.getAnalogIn()
digital = context.getDigital()
trigger = analog_in.getTrigger()
analog_in.enableChannel(libm2k.CHANNEL_1, True)
analog_in.enableChannel(libm2k.CHANNEL_2, True)
# configure the trigger
trigger.setAnalogDelay(-20)
trigger.setDigitalDelay(-20)
trigger.setAnalogLevel(ANALOG_CH, 2)
trigger.setDigitalCondition(DIGITAL_CH, libm2k.NONE)
trigger.setAnalogSource(ANALOG_CH)
trigger.setAnalogMode(ANALOG_CH, libm2k.ANALOG)
trigger.setAnalogCondition(ANALOG_CH, libm2k.RISING_EDGE_ANALOG)
# configure digital out interface
digital.setOutputMode(DIGITAL_CH, libm2k.DIO_PUSHPULL)
digital.setDirection(DIGITAL_CH, libm2k.DIO_OUTPUT)
digital.enableChannel(DIGITAL_CH, True)
digital.setCyclic(False)
# use the same samplerate for both analog and digital interface
analog_in.setSampleRate(SAMPLING_FREQUENCY)
analog_in.setOversamplingRatio(OVERSAMPLING)
digital.setSampleRateIn(SAMPLING_FREQUENCY // OVERSAMPLING)
# startMixedSignal -> extract the data -> stopMixedSignal
context.startMixedSignalAcquisition(BUFFER_SIZE)
generate_clock_signal(digital, SAMPLING_FREQUENCY // (10 * OVERSAMPLING))
digital_data, analog_data = [], []
digital_data.extend(digital.getSamples(BUFFER_SIZE))
analog_data.extend(analog_in.getSamples(BUFFER_SIZE))
context.stopMixedSignalAcquisition()
# get only the used digital channel
digital_data_one_ch = list(
map(lambda s: ((0x0001 << DIGITAL_CH) & int(s)) >> DIGITAL_CH,
digital_data))
plt.plot(digital_data_one_ch, label='Digital')
plt.plot(analog_data[ANALOG_CH], label='Analog')
plt.show()
libm2k.contextClose(context, True)
def main():
context = libm2k.m2kOpen("ip:192.168.2.1")
if context is None:
print(
'Connection Error: No ADALM2000 device available/connected to your PC.'
)
exit(1)
print('Calibrating ADC . . .')
context.calibrateADC()
power_supply = context.getPowerSupply()
power_supply.enableChannel(0, True)
power_supply.pushChannel(0, 3.3)
m2k_i2c_init = libm2k.m2k_i2c_init()
m2k_i2c_init.scl = 0
m2k_i2c_init.sda = 1
m2k_i2c_init.context = context
i2c_init_param = libm2k.i2c_init_param()
i2c_init_param.max_speed_hz = 100000
i2c_init_param.slave_address = 0x48
i2c_init_param.extra = m2k_i2c_init
i2c_desc = libm2k.i2c_init(i2c_init_param)
if i2c_desc is None:
print('I2C Error: Could not configure I2C')
exit(1)
print('Initiating I2C transfer . . .')
if libm2k.i2c_write(i2c_desc, bytearray([0x0B]), libm2k.i2c_general_call
| libm2k.i2c_repeated_start) == -1:
exit(1)
data_read_config = bytearray(1)
libm2k.i2c_read(i2c_desc, data_read_config, libm2k.i2c_general_call)
if len(data_read_config) == 0:
exit(1)
print('Reading the temperature . . .')
if libm2k.i2c_write(i2c_desc, bytearray([0]), libm2k.i2c_general_call
| libm2k.i2c_repeated_start) == -1:
exit(1)
data_read_temperature = bytearray(2)
libm2k.i2c_read(i2c_desc, data_read_temperature, libm2k.i2c_general_call)
if len(data_read_temperature) == 0:
exit(1)
temperature = convert_temperature(data_read_temperature)
print('Temperature: ' + str(temperature) + '\u2103')
libm2k.i2c_remove(i2c_desc)
libm2k.contextClose(context, True)
def setUp(self):
self.tb = gr.top_block()
self.ctx = libm2k.m2kOpen()
self.ctx.calibrateDAC()
self.analog_in = self.ctx.getAnalogIn()
self.analog_in.enableChannel(0, True)
self.analog_in.enableChannel(1, True)
self.analog_in.setSampleRate(100000)
self.analog_in.setRange(0, -10, 10)
def ConnectADALM(ctx=None):
if ctx is None:
ctx = libm2k.m2kOpen()
if ctx is None:
print(
"Connection Error: No ADALM2000 device available/connected to your PC."
)
exit(1)
pass
ctx.calibrateADC()
ctx.calibrateDAC()
pass
return ctx
def setUp(self):
self.tb = gr.top_block()
self.ctx = libm2k.m2kOpen()
self.ctx.calibrateDAC()
analog_out = self.ctx.getAnalogOut()
analog_out.setSampleRate(0, 75000)
analog_out.setSampleRate(1, 75000)
analog_out.enableChannel(0, True)
analog_out.enableChannel(1, True)
buffer1 = [1] * 1024
buffer2 = [3] * 1024
self.buffer = [buffer1, buffer2]
analog_out.setCyclic(True)
analog_out.push(self.buffer)
def main():
context = libm2k.m2kOpen()
if context is None:
print('Connection Error: No ADALM2000 device available/connected to your PC.')
exit(1)
digital = context.getDigital()
# setup SPI
m2k_spi_init = libm2k.m2k_spi_init()
m2k_spi_init.clock = 0
m2k_spi_init.mosi = 1
m2k_spi_init.miso = 3
m2k_spi_init.bit_numbering = libm2k.MSB
m2k_spi_init.cs_polarity = libm2k.ACTIVE_LOW
m2k_spi_init.context = context
spi_init_param = libm2k.spi_init_param()
spi_init_param.max_speed_hz = 1000000
spi_init_param.mode = libm2k.SPI_MODE_0
spi_init_param.chip_select = 2
spi_init_param.extra = m2k_spi_init
spi_desc = libm2k.spi_init(spi_init_param)
if spi_desc is None:
print('SPI Error: Could not configure SPI')
exit(1)
data = bytearray([0x4A, 0xF1])
buffer = libm2k.spi_create_buffer(spi_desc, data)
print(f'Digital buffer: {buffer}')
# here can be modified the data inside the digital buffer
# transmitting data
libm2k.spi_write_and_read_samples(spi_desc, buffer, data)
print(f'Received data: {data}') # received data
libm2k.spi_remove(spi_desc)
libm2k.contextClose(context, True)
def main():
context = libm2k.m2kOpen('ip:192.168.2.1')
if context is None:
print(
'Connection Error: No ADALM2000 device available/connected to your PC.'
)
exit(1)
m2k_uart_init = libm2k.m2k_uart_init()
m2k_uart_init.bits_number = 8
m2k_uart_init.parity = libm2k.NO_PARITY
m2k_uart_init.stop_bits = libm2k.ONE
m2k_uart_init.context = context
uart_init_param = libm2k.uart_init_param()
uart_init_param.device_id = 0
uart_init_param.baud_rate = 9600
uart_init_param.extra = m2k_uart_init
uart_desc_write = libm2k.uart_init(uart_init_param)
uart_init_param.device_id = 1
uart_desc_read = libm2k.uart_init(uart_init_param)
if uart_desc_write is None or uart_desc_read is None:
print('UART Error: Could not configure UART')
exit(1)
read_process = multiprocessing.Process(target=print_read_data,
args=(uart_desc_read, 3))
read_process.start()
time.sleep(1)
libm2k.uart_write(uart_desc_write, bytearray('ADI', 'utf-8'))
read_process.join()
libm2k.uart_remove(uart_desc_write)
libm2k.uart_remove(uart_desc_read)
libm2k.contextClose(context)
def main():
ctx = libm2k.m2kOpen(uri)
ctx.calibrateADC()
ctx.calibrateDAC()
siggen = ctx.getAnalogOut()
#call buffer generator, returns sample rate and buffer
samp0, buffer0 = sine_buffer_generator(0, 200000, 2, 0, 90)
samp1, buffer1 = sine_buffer_generator(1, 200000, 2, 0, 0)
siggen.enableChannel(0, True)
siggen.enableChannel(1, True)
siggen.setSampleRate(0, samp0)
siggen.setSampleRate(1, samp1)
siggen.push([buffer0, buffer1])
input(" Press any key to stop generation ")
siggen.stop()
libm2k.contextClose(ctx)
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# This example reads the analog voltage from channel 0 of the analog input
import libm2k as l
channel = 0
ctx = l.m2kOpen()
if ctx is None:
print(
"Connection Error: No ADALM2000 device available/connected to your PC."
)
exit(1)
ctx.calibrateADC()
ain = ctx.getAnalogIn()
ain.enableChannel(channel, True)
print(ain.getVoltage()[channel])
l.contextClose(ctx)
def main():
context = libm2k.m2kOpen('ip:192.168.2.1')
if context is None:
print(
'Connection Error: No ADALM2000 device available/connected to your PC.'
)
exit(1)
context.calibrateADC()
analog_in = context.getAnalogIn()
power_supply = context.getPowerSupply()
digital = context.getDigital()
# setup analog in
analog_in.setOversamplingRatio(1)
analog_in.setSampleRate(1000000)
analog_in.enableChannel(0, True)
analog_in.enableChannel(1, False)
analog_in.setRange(libm2k.ANALOG_IN_CHANNEL_1, libm2k.PLUS_MINUS_25V)
# enable LDAC
digital.setDirection(3, libm2k.DIO_OUTPUT)
digital.enableChannel(3, True)
# enable CLR
digital.setDirection(4, libm2k.DIO_OUTPUT)
digital.enableChannel(4, True)
# setup SPI
m2k_spi_init = libm2k.m2k_spi_init()
m2k_spi_init.clock = 1
m2k_spi_init.mosi = 2
m2k_spi_init.miso = 7 # dummy value - miso is not used in this example
m2k_spi_init.bit_numbering = libm2k.MSB
m2k_spi_init.context = context
spi_init_param = libm2k.spi_init_param()
spi_init_param.max_speed_hz = 1000000
spi_init_param.mode = libm2k.SPI_MODE_3
spi_init_param.chip_select = 0
spi_init_param.extra = m2k_spi_init
spi_desc = libm2k.spi_init(spi_init_param)
if spi_desc is None:
print('SPI Error: Could not configure SPI')
exit(1)
power_supply.enableChannel(0, True)
power_supply.pushChannel(0, 5)
# CLR and LDAC high as long as bits are transmitted
digital.setValueRaw(3, libm2k.HIGH)
digital.setValueRaw(4, libm2k.HIGH)
data = bytearray(get_register_data(VOLTAGE))
# transmitting data
libm2k.spi_write_and_read(spi_desc, data)
if len(data) == 0:
print('SPI Error: Could not transmit the data')
exit(1)
# update with current shift register contents
digital.setValueRaw(3, libm2k.LOW)
samples = analog_in.getSamples(100)
average = sum(samples[0]) / len(samples[0])
print('Average value: ' + str(average))
libm2k.spi_remove(spi_desc)
libm2k.contextClose(context, True)
# W1 -> 100-ohm resistor in series with speaker
# W2 -> open
# 2+ -> Microphone
# GND -> 1-
# GND -> 2-
#
# The application will record a few seconds of audio on scope channel 2, reverse the order of the samples,
# Apply some filtering tricks to remove large DC offsets, then play back. Playback is at 75% of record speed just due
# to available sample rates.
import libm2k
import matplotlib.pyplot as plt
import time
import numpy as np
ctx = libm2k.m2kOpen()
if ctx is None:
print(
"Connection Error: No ADALM2000 device available/connected to your PC."
)
exit(1)
ain = ctx.getAnalogIn()
aout = ctx.getAnalogOut()
trig = ain.getTrigger()
ps = ctx.getPowerSupply()
# Prevent bad initial config for ADC and DAC
ain.reset()
aout.reset()
ps.reset()
# This example assumes the following connections:
# W1 -> 1+
# W2 -> 2+
# GND -> 1-
# GND -> 2-
#
# The application will generate a sine and triangular wave on W1 and W2. The signal is fed back into the analog input
# and the voltage values are displayed on the screen
import libm2k
import matplotlib.pyplot as plt
import time
import numpy as np
ctx = libm2k.m2kOpen("ip:192.168.3.1")
if ctx is None:
print(
"Connection Error: No ADALM2000 device available/connected to your PC."
)
exit(1)
#ctx.calibrateADC()
ctx.calibrateDAC()
#ain=ctx.getAnalogIn()
aout = ctx.getAnalogOut()
#trig=ain.getTrigger()
#ain.enableChannel(0,True)
#ain.enableChannel(1,True)
def usage(name):
print("Usage: %s [-b|--boot|--bootloader]", argv[0])
exit(1)
if len(argv) == 2:
if argv[1] in ['-b', '--boot', '--bootloader']:
bootloader = True
else:
usage()
elif len(argv) == 1:
bootloader = False
else:
usage()
dev = libm2k.m2kOpen()
def reset(dev, bootloader):
io = dev.getDigital()
io.setDirection(RESET_PIN, libm2k.DIO_OUTPUT)
io.setOutputMode(RESET_PIN, libm2k.DIO_OPENDRAIN)
io.setDirection(BOOT0_PIN, libm2k.DIO_OUTPUT)
io.setOutputMode(BOOT0_PIN, libm2k.DIO_PUSHPULL)
io.setValueRaw(BOOT0_PIN, 1 if bootloader else 0)
io.setValueRaw(RESET_PIN, 0)
sleep(0.1)
io.setValueRaw(RESET_PIN, 1)
sleep(0.1)
sampling_frequency_in = 10000000
sampling_frequency_out = 750000
def generate_clock_signal(digital, channel, sampling_frequency):
digital.setSampleRateOut(sampling_frequency)
duty = SAMPLES_PER_PERIOD / 2 # 50%
signal = np.arange(SAMPLES_PER_PERIOD) < duty
buffer = list(map(lambda s: int(s) << channel, signal))
for i in range(2):
buffer.extend(buffer)
print(buffer)
return buffer
ctx = libm2k.m2kOpen("replace with uri for 1st M2K")
ctx2 = libm2k.m2kOpen("replace with uri for 2nd M2K")
if ctx is None:
print("Connection Error: No ADALM2000 device available/connected to your PC.")
exit(1)
if ctx2 is None:
print("Connection Error: No second ADALM2000 device available/connected to your PC.")
exit(1)
ctx.calibrateADC()
ctx.calibrateDAC()
ctx2.calibrateADC()
ctx2.calibrateDAC()
# Configure 1st M2K context
# Set the output buffer size (No), and rate
No = 280 # <-------- This needs to be a multiple of 4 to work right
ao_rate = 75000.0
# Stable buffer sizes seem to be multiples of 4.
# Tested to show no beating: No = 260, 264, 268, 272, 276, 280, ..., 300
# Get a reasonable frequency.
f = ao_rate / No * 8 # 11 complete cycles in 275 points at 3 kHz
print('Frequency =', f)
# Get the first m2k name
name = libm2k.getAllContexts()[0]
# Get the m2k
m2k = libm2k.m2kOpen(name).toM2k()
# Run the calibration
m2k.calibrate()
# Enable the outputs and set the rates.
ao = m2k.getAnalogOut()
ao.enableChannel(0, True)
ao.enableChannel(1, True)
ao.setSampleRate(0, ao_rate)
ao.setSampleRate(1, ao_rate)
# Create waveform arrays: sinusoid and square pulse
#
# 75 kHz sampling rate: 2 kHz good,
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import adi
import libm2k
import matplotlib.pyplot as plt
import numpy as np
from scipy import signal
import sys
from time import sleep
from signal_chain_functions import *
aout_sr = 75000
ain_sr = 1000000
ctx = libm2k.m2kOpen(
"ip:192.168.2.1") # Explicitly call out default IP address
if ctx is None:
print(
"Connection Error: No ADALM2000 device available/connected to your PC."
)
exit(1)
ctx.calibrateADC()
ctx.calibrateDAC()
ain = ctx.getAnalogIn()
aout = ctx.getAnalogOut()
trig = ain.getTrigger()
ain.enableChannel(0, True)
ain.enableChannel(1, True)
