def main():
"""
This function is executed automatically when the module is run directly.
"""
# Store the channels in a list and convert the list to a channel mask that
# can be passed as a parameter to the MCC 128 functions.
channels = [0, 1, 2, 3]
channel_mask = chan_list_to_mask(channels)
num_channels = len(channels)
input_mode = AnalogInputMode.SE
input_range = AnalogInputRange.BIP_10V
samples_per_channel = 0
options = OptionFlags.CONTINUOUS
scan_rate = 1000.0
try:
# Select an MCC 128 HAT device to use.
address = select_hat_device(HatIDs.MCC_128)
hat = mcc128(address)
hat.a_in_mode_write(input_mode)
hat.a_in_range_write(input_range)
print('\nSelected MCC 128 HAT device at address', address)
actual_scan_rate = hat.a_in_scan_actual_rate(num_channels, scan_rate)
print('\nMCC 128 continuous scan example')
print(' Functions demonstrated:')
print(' mcc128.a_in_scan_start')
print(' mcc128.a_in_scan_read')
print(' mcc128.a_in_scan_stop')
print(' mcc128.a_in_scan_cleanup')
print(' mcc128.a_in_mode_write')
print(' mcc128.a_in_range_write')
print(' Input mode: ', input_mode_to_string(input_mode))
print(' Input range: ', input_range_to_string(input_range))
print(' Channels: ', end='')
print(', '.join([str(chan) for chan in channels]))
print(' Requested scan rate: ', scan_rate)
print(' Actual scan rate: ', actual_scan_rate)
print(' Options: ', enum_mask_to_string(OptionFlags, options))
try:
input('\nPress ENTER to continue ...')
except (NameError, SyntaxError):
pass
# Configure and start the scan.
# Since the continuous option is being used, the samples_per_channel
# parameter is ignored if the value is less than the default internal
# buffer size (10000 * num_channels in this case). If a larger internal
# buffer size is desired, set the value of this parameter accordingly.
hat.a_in_scan_start(channel_mask, samples_per_channel, scan_rate,
options)
print('Starting scan ... Press Ctrl-C to stop\n')
# Display the header row for the data table.
print('Samples Read Scan Count', end='')
for chan, item in enumerate(channels):
print(' Channel ', item, sep='', end='')
print('')
try:
read_and_display_data(hat, num_channels)
except KeyboardInterrupt:
# Clear the '^C' from the display.
print(CURSOR_BACK_2, ERASE_TO_END_OF_LINE, '\n')
print('Stopping')
hat.a_in_scan_stop()
hat.a_in_scan_cleanup()
except (HatError, ValueError) as err:
print('\n', err)
def main():
"""
This function is executed automatically when the module is run directly.
"""
# Store the channels in a list and convert the list to a channel mask that
# can be passed as a parameter to the MCC 128 functions.
channels = [0, 1, 2, 3]
channel_mask = chan_list_to_mask(channels)
num_channels = len(channels)
input_mode = AnalogInputMode.SE
input_range = AnalogInputRange.BIP_10V
samples_per_channel = 10000
scan_rate = 1000.0
options = OptionFlags.EXTTRIGGER
trigger_mode = TriggerModes.RISING_EDGE
try:
# Select an MCC 128 HAT device to use.
address = select_hat_device(HatIDs.MCC_128)
hat = mcc128(address)
hat.a_in_mode_write(input_mode)
hat.a_in_range_write(input_range)
print('\nSelected MCC 128 HAT device at address', address)
actual_scan_rate = hat.a_in_scan_actual_rate(num_channels, scan_rate)
print('\nMCC 128 continuous scan example')
print(' Functions demonstrated:')
print(' mcc128.trigger_mode')
print(' mcc128.a_in_scan_status')
print(' mcc128.a_in_scan_start')
print(' mcc128.a_in_scan_read')
print(' mcc128.a_in_scan_stop')
print(' mcc128.a_in_scan_cleanup')
print(' mcc128.a_in_mode_write')
print(' mcc128.a_in_range_write')
print(' Input mode: ', input_mode_to_string(input_mode))
print(' Input range: ', input_range_to_string(input_range))
print(' Channels: ', end='')
print(', '.join([str(chan) for chan in channels]))
print(' Requested scan rate: ', scan_rate)
print(' Actual scan rate: ', actual_scan_rate)
print(' Samples per channel', samples_per_channel)
print(' Options: ', enum_mask_to_string(OptionFlags, options))
print(' Trigger Mode: ', trigger_mode.name)
try:
input('\nPress ENTER to continue ...')
except (NameError, SyntaxError):
pass
hat.trigger_mode(trigger_mode)
# Configure and start the scan.
hat.a_in_scan_start(channel_mask, samples_per_channel, scan_rate,
options)
try:
# wait for the external trigger to occur
print('\nWaiting for trigger ... hit Ctrl-C to cancel the trigger')
wait_for_trigger(hat)
print('\nStarting scan ... Press Ctrl-C to stop\n')
# Display the header row for the data table.
print('Samples Read Scan Count', end='')
for chan in channels:
print(' Channel ', chan, sep='', end='')
print('')
read_and_display_data(hat, samples_per_channel, num_channels)
except KeyboardInterrupt:
# Clear the '^C' from the display.
print(CURSOR_BACK_2, ERASE_TO_END_OF_LINE, '\n')
hat.a_in_scan_stop()
hat.a_in_scan_cleanup()
except (HatError, ValueError) as err:
print('\n', err)
def main():
"""
This function is executed automatically when the module is run directly.
"""
options = OptionFlags.DEFAULT
low_chan = 0
high_chan = 3
input_mode = AnalogInputMode.SE
input_range = AnalogInputRange.BIP_10V
mcc_128_num_channels = mcc128.info().NUM_AI_CHANNELS[input_mode]
sample_interval = 0.5 # Seconds
try:
# Ensure low_chan and high_chan are valid.
if low_chan < 0 or low_chan >= mcc_128_num_channels:
error_message = ('Error: Invalid low_chan selection - must be '
'0 - {0:d}'.format(mcc_128_num_channels - 1))
raise Exception(error_message)
if high_chan < 0 or high_chan >= mcc_128_num_channels:
error_message = ('Error: Invalid high_chan selection - must be '
'0 - {0:d}'.format(mcc_128_num_channels - 1))
raise Exception(error_message)
if low_chan > high_chan:
error_message = ('Error: Invalid channels - high_chan must be '
'greater than or equal to low_chan')
raise Exception(error_message)
# Get an instance of the selected hat device object.
address = select_hat_device(HatIDs.MCC_128)
hat = mcc128(address)
hat.a_in_mode_write(input_mode)
hat.a_in_range_write(input_range)
print('\nMCC 128 single data value read example')
print(' Functions demonstrated:')
print(' mcc128.a_in_read')
print(' mcc128.a_in_mode_write')
print(' mcc128.a_in_range_write')
print(' Input mode: ', input_mode_to_string(input_mode))
print(' Input range: ', input_range_to_string(input_range))
print(' Channels: {0:d} - {1:d}'.format(low_chan, high_chan))
print(' Options:', enum_mask_to_string(OptionFlags, options))
try:
input("\nPress 'Enter' to continue")
except (NameError, SyntaxError):
pass
print('\nAcquiring data ... Press Ctrl-C to abort')
# Display the header row for the data table.
print('\n Samples/Channel', end='')
for chan in range(low_chan, high_chan + 1):
print(' Channel', chan, end='')
print('')
try:
samples_per_channel = 0
while True:
# Display the updated samples per channel count
samples_per_channel += 1
print('\r{:17}'.format(samples_per_channel), end='')
# Read a single value from each selected channel.
for chan in range(low_chan, high_chan + 1):
value = hat.a_in_read(chan, options)
print('{:12.5} V'.format(value), end='')
stdout.flush()
# Wait the specified interval between reads.
sleep(sample_interval)
except KeyboardInterrupt:
# Clear the '^C' from the display.
print(CURSOR_BACK_2, ERASE_TO_END_OF_LINE, '\n')
except (HatError, ValueError) as error:
print('\n', error)
def main():
"""
This function is executed automatically when the module is run directly.
"""
hats = []
# Define the input modes for each MCC 128
input_modes = [AnalogInputMode.SE, AnalogInputMode.SE]
# Define the input ranges for each MCC 128
input_ranges = [AnalogInputRange.BIP_10V, AnalogInputRange.BIP_10V]
# Define the channel list for each HAT device
chans = [{0, 1}, {0, 1}]
# Define the options for each HAT device
options = [OptionFlags.EXTTRIGGER, OptionFlags.EXTCLOCK]
samples_per_channel = 10000
sample_rate = 1000.0 # Samples per second
trigger_mode = TriggerModes.RISING_EDGE
try:
# Get an instance of the selected hat device object.
hats = select_hat_devices(HatIDs.MCC_128, DEVICE_COUNT)
# Validate the selected channels, set the modes and ranges.
for i, hat in enumerate(hats):
validate_channels(chans[i],
hat.info().NUM_AI_CHANNELS[input_modes[i]])
hat.a_in_mode_write(input_modes[i])
hat.a_in_range_write(input_ranges[i])
# Set the trigger mode for the master device.
hats[MASTER].trigger_mode(trigger_mode)
# Calculate the actual sample rate.
actual_rate = hats[MASTER].a_in_scan_actual_rate(
len(chans[MASTER]), sample_rate)
print('MCC 128 multiple HAT example using external clock and',
'external trigger options')
print(' Functions demonstrated:')
print(' mcc128.trigger_mode')
print(' mcc128.a_in_scan_start')
print(' mcc128.a_in_scan_status')
print(' mcc128.a_in_scan_read')
print(' mcc128.a_in_scan_stop')
print(' mcc128.a_in_scan_cleanup')
print(' mcc128.a_in_mode_write')
print(' mcc128.a_in_range_write')
print(' Samples per channel:', samples_per_channel)
print(' Requested Sample Rate: {:.3f} Hz'.format(sample_rate))
print(' Actual Sample Rate: {:.3f} Hz'.format(actual_rate))
print(' Trigger type:', trigger_mode.name)
for i, hat in enumerate(hats):
print(' HAT {}:'.format(i))
print(' Address:', hat.address())
print(' Input mode: ', input_mode_to_string(input_modes[i]))
print(' Input range: ',
input_range_to_string(input_ranges[i]))
print(' Channels: ', end='')
print(', '.join([str(chan) for chan in chans[i]]))
options_str = enum_mask_to_string(OptionFlags, options[i])
print(' Options:', options_str)
print('\n*NOTE: Connect the CLK terminals together on each MCC 128')
print(' HAT device being used. Connect a trigger source')
print(' to the TRIG input terminal on HAT 0.')
try:
input("\nPress 'Enter' to continue")
except (NameError, SyntaxError):
pass
# Start the scan.
for i, hat in enumerate(hats):
chan_mask = chan_list_to_mask(chans[i])
hat.a_in_scan_start(chan_mask, samples_per_channel, sample_rate,
options[i])
print('\nWaiting for trigger ... Press Ctrl-C to stop scan\n')
try:
# Monitor the trigger status on the master device.
wait_for_trigger(hats[MASTER])
# Read and display data for all devices until scan completes
# or overrun is detected.
read_and_display_data(hats, chans)
except KeyboardInterrupt:
# Clear the '^C' from the display.
print(CURSOR_BACK_2, ERASE_TO_END_OF_LINE, '\nAborted\n')
except (HatError, ValueError) as error:
print('\n', error)
finally:
for hat in hats:
hat.a_in_scan_stop()
hat.a_in_scan_cleanup()