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 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 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)
aout.setSampleRate(0, 7500)
aout.setSampleRate(1, 7500)
aout.enableChannel(0, True)
aout.enableChannel(1, True)
print("aout sample rate: " + str(aout.getSampleRate()))
audio = data[1]
gain = 100.0
dc = np.convolve(audio, (np.ones(64) / 64.0),
mode='same') # Calculate running DC average
audio = audio - dc
audio[0:100] = [0] * 100 # get rid of edge effect
normal_audio = audio
audio = np.flip(audio) # Here's where the flip happens!!
audio = audio * gain # add some gain
# Push data
buffer = [audio, audio]
aout.setCyclic(True)
aout.push(buffer)
# Plot audio data
plt.plot(audio, label="flipped audio")
plt.plot(np.array(normal_audio * gain), label="normal audio")
plt.legend()
plt.show()
time.sleep(5)
libm2k.contextClose(ctx)
def run_specific_tests_from_C_PowerSupplyTests():
"""Test suite for C_Power_SupplyTests where the used can choose the desired test
Available Power Supply tests: test_negative_power_supply, test_positive_power_supply
"""
suite = unittest.TestSuite()
suite.addTest(C_PowerSupplyTests("test_1_power_supply_object")) #test necessary to retrieve the power supply object
suite.addTest(C_PowerSupplyTests("add_test_name_here")) #add the name of the test between " "
#you can add manytests from the available ones using the line above as example
runner = unittest.TextTestRunner()
runner.run(suite)
return
if __name__ =="__main__":
"""Main file where tests for all segments are called. The test classes are organized in a test suite.
To run specific tests, comment run_test_suite() line and uncomment run_specific_tests_from...() line(s)
"""
run_test_suite()
#run_specific_tests_from_A_AnalogTests()
#run_specific_tests_from_B_TriggerTests()
#run_specific_tests_from_C_PowerSupplyTests()
libm2k.contextClose(ctx, True)
def tearDown(self):
self.tb = None
libm2k.contextClose(self.ctx)
def signal_handler(sig, frame):
nonlocal calibration_values
write_in_file(calibration_values, args.values, args.file)
libm2k.contextClose(ctx)
sys.exit(0)
def close_app():
libm2k.contextClose(ctx)
print("context closed")
window.destroy()
