def ResetMcc152(): boardAddr = select_hat_device(HatIDs.MCC_152) board = mcc152(boardAddr) board.dio_reset() return jsonify("MCC152 RESET")
def main(): """ This function is executed automatically when the module is run directly. """ options = OptionFlags.DEFAULT print('MCC 152 all channel analog output example.') print('Writes the specified voltages to the analog outputs.') print(" Methods demonstrated:") print(" mcc152.a_out_write_all") print(" mcc152.info") print() # Get an instance of the selected hat device object. address = select_hat_device(HatIDs.MCC_152) print("\nUsing address {}.\n".format(address)) hat = mcc152(address) run_loop = True error = False while run_loop and not error: # Get the values from the user. try: values = get_input_values() except ValueError: run_loop = False else: # Write the values. try: hat.a_out_write_all(values=values, options=options) except (HatError, ValueError): error = True
def main(): """ This function is executed automatically when the module is run directly. """ print("MCC 152 digital output write example.") print("Sets all digital I/O channels to outputs then gets values from") print("the user and updates the outputs. The value can be specified") print("as decimal (0 - 255,) hexadecimal (0x0 - 0xFF,)") print("octal (0o0 - 0o377,) or binary (0b0 - 0b11111111.)") print(" Methods demonstrated:") print(" mcc152.dio_reset") print(" mcc152.dio_output_write_port") print(" mcc152.dio_config_write_port") print(" mcc152.info") print() # Get an instance of the selected hat device object. address = select_hat_device(HatIDs.MCC_152) print("\nUsing address {}.\n".format(address)) hat = mcc152(address) # Reset the DIO to defaults (all channels input, pull-up resistors # enabled). hat.dio_reset() # Set all channels as outputs. try: hat.dio_config_write_port(DIOConfigItem.DIRECTION, 0x00) except (HatError, ValueError): print("Could not configure the port as outputs.") sys.exit() run_loop = True error = False # Loop until the user terminates or we get a library error. while run_loop and not error: write_value = get_input() if write_value is None: run_loop = False else: try: hat.dio_output_write_port(write_value) except (HatError, ValueError): error = True if error: print("Error writing the outputs.") # Return the DIO to default settings if not error: hat.dio_reset()
def main(): """ This function is executed automatically when the module is run directly. """ print("MCC 152 digital output write example.") print("Sets all digital I/O channels to output then gets channel and") print("value input from the user and updates the output.") print(" Methods demonstrated:") print(" mcc152.dio_reset") print(" mcc152.dio_output_write_bit") print(" mcc152.dio_config_write_bit") print(" mcc152.info") print() # Get an instance of the selected hat device object. address = select_hat_device(HatIDs.MCC_152) print("\nUsing address {}.\n".format(address)) hat = mcc152(address) # Reset the DIO to defaults (all channels input, pull-up resistors # enabled). hat.dio_reset() # Set all channels as outputs. for channel in range(mcc152.info().NUM_DIO_CHANNELS): try: hat.dio_config_write_bit(channel, DIOConfigItem.DIRECTION, 0) except (HatError, ValueError): print("Could not configure the channel as output.") sys.exit() run_loop = True error = False # Loop until the user terminates or we get a library error. while run_loop and not error: channel, value = get_input() if channel is None: run_loop = False else: try: hat.dio_output_write_bit(channel, value) except (HatError, ValueError): error = True if error: print("Error writing the output.") # Return the DIO to default settings if not error: hat.dio_reset()
def main(): """ This function is executed automatically when the module is run directly. """ print("MCC 152 digital input read example.") print("Reads the inputs individually and displays their state.") print(" Methods demonstrated:") print(" mcc152.dio_reset") print(" mcc152.dio_input_read_bit") print(" mcc152.info") print() # Get an instance of the selected hat device object. address = select_hat_device(HatIDs.MCC_152) print("\nUsing address {}.\n".format(address)) hat = mcc152(address) # Reset the DIO to defaults (all channels input, pull-up resistors # enabled). hat.dio_reset() num_channels = hat.info().NUM_DIO_CHANNELS run_loop = True error = False # Loop until the user terminates or we get a library error. while run_loop and not error: # Read and display the individual channels. for channel in range(num_channels): try: value = hat.dio_input_read_bit(channel) except (HatError, ValueError): error = True break else: print("DIO{0}: {1}\t".format(channel, value), end="") if error: print("\nError reading the input.") else: # Wait for the user to enter a response message = "\nEnter Q to exit, anything else to read again: " if version_info.major > 2: response = input(message) else: response = raw_input(message) if response == "q" or response == "Q": # Exit the loop run_loop = False
def api_id(): if 'id' in request.args: id = int(request.args['id']) else: return "Error detected" #get MCC152 board address boardAddr = select_hat_device(HatIDs.MCC_152) board = mcc152(boardAddr) bit = (0, 1, 2, 3, 4, 5, 6, 7, 8) board.dio_config_write_port(DIOConfigItem.DIRECTION, 0x00) board.dio_output_write_port(id) bit0 = str(board.dio_input_read_bit(0)) bit1 = str(board.dio_input_read_bit(1)) bit2 = str(board.dio_input_read_bit(2)) bit3 = str(board.dio_input_read_bit(3)) bit4 = str(board.dio_input_read_bit(4)) bit5 = str(board.dio_input_read_bit(5)) bit6 = str(board.dio_input_read_bit(6)) bit7 = str(board.dio_input_read_bit(7)) myDIO = [{ 'bit': 0, 'value': bit0, }, { 'bit': 1, 'value': bit1, }, { 'bit': 2, 'value': bit2, }, { 'bit': 3, 'value': bit3, }, { 'bit': 4, 'value': bit4, }, { 'bit': 5, 'value': bit5, }, { 'bit': 6, 'value': bit7, }, { 'bit': 7, 'value': bit7, }] return jsonify(myDIO)
def init_daq(self): try: address = select_hat_device(HatIDs.MCC_118) self.hat = mcc118(address) num_channels = len(self.ai_ch) self.scan_rate = self.hat.a_in_scan_actual_rate(num_channels, self.scan_rate) self.read_request_size = int(self.scan_rate*self.acq_dur) except (NameError, SyntaxError): pass
def AnaOut0(): if 'id' in request.args: id = float(request.args['id']) else: return "Error detected" options = OptionFlags.DEFAULT boardAddr = select_hat_device(HatIDs.MCC_152) board = mcc152(boardAddr) board.a_out_write(channel=0, value=id, options=options) return "SUCCESS"
def main(): """ This function is executed automatically when the module is run directly. """ print("MCC 152 digital input read example.") print("Reads the inputs as a port and displays their state.") print(" Methods demonstrated:") print(" mcc152.dio_reset") print(" mcc152.dio_input_read_port") print() # Get an instance of the selected hat device object. address = select_hat_device(HatIDs.MCC_152) print("\nUsing address {}.\n".format(address)) hat = mcc152(address) # Reset the DIO to defaults (all channels input, pull-up resistors # enabled). hat.dio_reset() run_loop = True error = False # Loop until the user terminates or we get a library error. while run_loop and not error: # Read and display the inputs try: value = hat.dio_input_read_port() except (HatError, ValueError): error = True break else: print("Digital Inputs: 0x{0:02X}".format(value)) if error: print("Error reading the inputs.") else: print("Enter Q to exit, anything else to read again: ") # Wait for the user to enter a response if version_info.major > 2: response = input("") else: response = raw_input("") if response == "q" or response == "Q": # Exit the loop run_loop = False
def main(): """ This function is executed automatically when the module is run directly. """ options = OptionFlags.DEFAULT channel = 0 num_channels = mcc152.info().NUM_AO_CHANNELS # Ensure channel is valid. if channel not in range(num_channels): error_message = ('Error: Invalid channel selection - must be ' '0 - {}'.format(num_channels - 1)) raise Exception(error_message) print('MCC 152 single channel analog output example.') print('Writes the specified voltage to the analog output.') print(" Methods demonstrated:") print(" mcc152.a_out_write") print(" mcc152.info") print(" Channel: {}\n".format(channel)) # Get an instance of the selected hat device object. address = select_hat_device(HatIDs.MCC_152) print("\nUsing address {}.\n".format(address)) hat = mcc152(address) run_loop = True error = False while run_loop and not error: # Get the value from the user. try: value = get_input_value() except ValueError: run_loop = False else: # Write the value to the selected channel. try: hat.a_out_write(channel=channel, value=value, options=options) except (HatError, ValueError): error = True if error: print("Error writing analog output.")
def BitStatus(): if 'id' in request.args: id = int(request.args['id']) else: return "error detected" boardAddr = select_hat_device(HatIDs.MCC_152) board = mcc152(boardAddr) bitValue = board.dio_input_read_bit(6) #buttonStatus = [ # {'bitStatus': id, # 'bitValue': bitValue} # ] return str(bitValue)
def ButtonClear(): options = OptionFlags.DEFAULT if 'id' in request.args: id = int(request.args['id']) else: return jsonify("Error detected clearing bit 6") boardAddr = select_hat_device(HatIDs.MCC_152) board = mcc152(boardAddr) board.dio_output_write_bit(6, 0) board.a_out_write(channel=1, value=0, options=options) buttonReset = [{ 'ButtonStatus': id, 'value': board.dio_input_read_bit(6), }] return jsonify(buttonReset)
def single_channel_scan(channel=0): global size global rate address = select_hat_device(HatIDs.MCC_118) hat = mcc118(address) channels = [channel] channel_mask = chan_list_to_mask(channels) options = OptionFlags.DEFAULT hat.a_in_scan_start(channel_mask, size, rate, options) # size, rate raw = hat.a_in_scan_read(size, size/rate+1) # size, rate hat.a_in_scan_cleanup() raw_data = np.array(raw.data) fft_data = fftpack.fft(raw_data) fft_data = np.abs(fft_data[0:size]) * 2 / (0.6 * size) fft_data = fft_data[:len(fft_data)/2] return raw_data, fft_data
def AnaIN(): if 'id' in request.args: id = int(request.args['id']) else: return "Error detected" options = OptionFlags.DEFAULT boardAddr = select_hat_device(HatIDs.MCC_118) board = mcc118(boardAddr) value = board.a_in_read(id, options) #value = value * 2 #value = "{:.2f}".format(value) myAnalogIn = [{ 'chan': id, 'value': value, }] return jsonify(myAnalogIn)
def init_dev(self): address = select_hat_device(HatIDs.MCC_152) self.HAT = mcc152(address) # Reset the DIO to defaults (all channels input, pull-up resistors # enabled). self.HAT.dio_reset() # Read the initial input values so we don't trigger an interrupt when # we enable them. self.HAT.dio_input_read_port() # set digital ouptput channels for ch in self.do_ch: try: self.HAT.dio_config_write_bit(ch, DIOConfigItem.DIRECTION, 0) # since default output register value is 1, # reset to 0 self.write_outputvalue(ch, 0) except (HatError, ValueError): logging.error( 'could not configure the channel{} as output'.format(ch)) sys.exit() # set digital iput channels as latched input for ch in self.di_ch: try: self.HAT.dio_config_write_bit(ch, DIOConfigItem.DIRECTION, 1) # Enable latched inputs so we know that a value changed even if it changes # back to the original value before the interrupt callback. self.HAT.dio_config_write_bit(ch, DIOConfigItem.INPUT_LATCH, 1) # interrupt enabled self.HAT.dio_config_write_bit(ch, DIOConfigItem.INT_MASK, 0) except (HatError, ValueError): logging.error( 'could not configure the channel{} as output'.format(ch)) sys.exit() self.callback = HatCallback(self.interrupt_callback)
def openDaq(self, DaqStreamInfo): self.DaqStreamInfo = DaqStreamInfo self.options = DaqStreamInfo.options self.low_chan = DaqStreamInfo.low_chan self.high_chan = DaqStreamInfo.high_chan self.input_mode = DaqStreamInfo.input_mode self.input_range = DaqStreamInfo.input_range self.mcc_128_num_channels = DaqStreamInfo.mcc_128_num_channels self.sample_interval = DaqStreamInfo.sample_interval self.guid = getGUID() #print(self.guid) try: # Ensure low_chan and high_chan are valid. if self.low_chan < 0 or self.low_chan >= self.mcc_128_num_channels: error_message = ('Error: Invalid low_chan selection - must be ' '0 - {0:d}'.format(self.mcc_128_num_channels - 1)) raise Exception(error_message) if self.high_chan < 0 or self.high_chan >= self.mcc_128_num_channels: error_message = ( 'Error: Invalid high_chan selection - must be ' '0 - {0:d}'.format(self.mcc_128_num_channels - 1)) raise Exception(error_message) if self.low_chan > self.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) self.hat = mcc128(address) self.hat.a_in_mode_write(self.input_mode) self.hat.a_in_range_write(self.input_range) self.sensor = self.hat except (HatError, ValueError) as error: print('\n', error)
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 118 functions. no_of_channels = 1 # Creates the list of channels. channels = np.ndarray.tolist(np.arange((no_of_channels), dtype=int)) channel_mask = chan_list_to_mask(channels) num_channels = len(channels) samples = 4000 if (num_channels % 2) == 0: samples_per_channel = int(samples / num_channels) else: samples_per_channel = int(mt.ceil(samples / num_channels)) scan_rate = 4000 options = OptionFlags.DEFAULT timeout = 10.0 try: # Select an MCC 118 HAT device to use. address = select_hat_device(HatIDs.MCC_118) hat = mcc118(address) print('\nSelected MCC 118 HAT device at address', address) actual_scan_rate = hat.a_in_scan_actual_rate(num_channels, scan_rate) print('\nMCC 118 continuous scan example') print(' Functions demonstrated:') print(' mcc118.a_in_scan_start') print(' mcc118.a_in_scan_read') 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)) #try: #input('\nPress ENTER to continue ...') #except (NameError, SyntaxError): #pass # Configure and start the scan. hat.a_in_scan_start(channel_mask, samples_per_channel, scan_rate, options) print('Starting scan ... Press Ctrl-C to stop\n') """Try reading when scanning?""" read_output = hat.a_in_scan_read_numpy( samples_per_channel * num_channels, timeout) # Changed the sampling size to create even arrays chan_data = np.zeros([samples_per_channel, num_channels]) chan_title = [] #### NEW CODE ################################################################### for i in range(num_channels): for j in range(samples_per_channel): if j == 0: y = str('Channel') + ' ' + str(i) chan_title.append(str(y)) if i < samples_per_channel - num_channels: chan_data[:, i] = read_output[i::num_channels] chan_final = np.concatenate((np.reshape(np.array(chan_title), (1, num_channels)), chan_data), axis=0) np.savetxt('foo.csv', chan_final, fmt='%5s', delimiter=',') ######################################################################################## """ for i in range (num_channels): for j in range (samples_per_channel): if j==0: y = str("Channel") + " " + str(i) chan_data.append(y)#[i,j] = str("Channel") + " " + str(i) x= read_output.data[i] chan_data.append(x) #chan_data[:,i] = read_output.data[i] chan_data2 = np.asarray(chan_data, dtype = str) print(y) print(x) print(chan_data2) f = open("bar.txt", "a") f.write(chan_data2) f.close #np.savetxt("foo.csv", chan_data, delimiter=",") """ # Display the header row for the data table. print('Samples Read Scan Count', end='') for chan in channels: print(' Channel ', chan, sep='', end='') print('') try: 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') 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 118 functions. channels = [0,1] channel_mask = chan_list_to_mask(channels) num_channels = len(channels) samples_per_channel = 4000 scan_rate = 4000 options = OptionFlags.EXTTRIGGER trigger_mode = TriggerModes.ACTIVE_HIGH timeout = 5.0 try: # Select an MCC 118 HAT device to use. address = select_hat_device(HatIDs.MCC_118) hat = mcc118(address) print('\nSelected MCC 118 HAT device at address', address) actual_scan_rate = hat.a_in_scan_actual_rate(num_channels, scan_rate) print('\nMCC 118 continuous scan example') print(' Functions demonstrated:') print(' mcc118.trigger_mode') print(' mcc118.a_in_scan_status') print(' mcc118.a_in_scan_start') print(' mcc118.a_in_scan_read') 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') """read complete output data and place int array""" read_output = hat.a_in_scan_read_numpy(samples_per_channel, timeout) """create a blank array""" chan_data = np.zeros([samples_per_channel, num_channels]) chan_title = [] for i in range(num_channels): for j in range(samples_per_channel): if j ==0: y = str('Channel') + ' ' + str(i) chan_title.append(str(y)) chan_data[:, i] = read_output.data[i] chan_final = np.concatenate((np.reshape(np.array(chan_title), (1, num_channels)), chan_data), axis = 0) np.savetxt('force_data.csv', chan_final, fmt = '%5s', delimiter = ',') for i in range (num_channels): max_data = max(chan_data[:,i]) print("Max Ch",(i),":", max_data) temperature() print(temperature()) print(max(read_output.data)*12) #except KeyboardInterrupt: # Clear the '^C' from the display. #print(CURSOR_BACK_2, ERASE_TO_END_OF_LINE, '\n') except (HatError, ValueError) as err: print('\n', err)
delay = 3 while True: # start time import time t = time.time() '''-------------------------------------------------------M C C 1 1 8 S C A N-----------------------------------------------------''' from daqhats import mcc118, OptionFlags, HatIDs, HatError from daqhats_utils import select_hat_device, chan_list_to_mask address = select_hat_device(HatIDs.MCC_118) hat = mcc118(address) channels = [0] channel_mask = chan_list_to_mask(channels) sample_size = 2048 rate = 10000 options = OptionFlags.DEFAULT request = sample_size timeout = 3 hat.a_in_scan_start(channel_mask, sample_size, rate, options) raw = hat.a_in_scan_read(request, timeout) hat.a_in_scan_cleanup() if len(raw.data) == sample_size: '''----------------------------------------------F F T / F F T P E A K S-------------------------------------------------'''
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 118 functions. channels = [0, 1, 2, 3] channel_mask = chan_list_to_mask(channels) num_channels = len(channels) samples_per_channel = 4000 scan_rate = 4000.0 timeout = 1.0 options = OptionFlags.DEFAULT try: # Select an MCC 118 HAT device to use. address = select_hat_device(HatIDs.MCC_118) hat = mcc118(address) print('\nSelected MCC 118 HAT device at address', address) actual_scan_rate = hat.a_in_scan_actual_rate(num_channels, scan_rate) print('\nMCC 118 continuous scan example') print(' Functions demonstrated:') print(' mcc118.a_in_scan_start') print(' mcc118.a_in_scan_read') 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)) #try: #input('\nPress ENTER to continue ...') #except (NameError, SyntaxError): #pass # Configure and start the scan. hat.a_in_scan_start(channel_mask, samples_per_channel, scan_rate, options) print('Starting scan ... Press Ctrl-C to stop\n') """Try reading when scanning?""" read_output = hat.a_in_scan_read_numpy(samples_per_channel, timeout) chan_data = np.zeros([samples_per_channel, num_channels]) for i in range(num_channels): chan_data[:, i] = read_output.data[i] np.savetxt("foo.csv", chan_data, delimiter=",") # Display the header row for the data table. #print('Samples Read Scan Count', end='') #for chan in channels: #print(' Channel ', chan, sep='', end='') #print('') #try: #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') except (HatError, ValueError) as err: print('\n', err)
def main(): # pylint: disable=too-many-locals, too-many-statements """ 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 172 functions. channels = [0, 1] channel_mask = chan_list_to_mask(channels) num_channels = len(channels) samples_per_channel = 0 options = OptionFlags.CONTINUOUS scan_rate = 10240.0 try: # Select an MCC 172 HAT device to use. address = select_hat_device(HatIDs.MCC_172) hat = mcc172(address) print('\nSelected MCC 172 HAT device at address', address) # Turn on IEPE supply? iepe_enable = get_iepe() for channel in channels: hat.iepe_config_write(channel, iepe_enable) # Configure the clock and wait for sync to complete. hat.a_in_clock_config_write(SourceType.LOCAL, scan_rate) synced = False while not synced: (_source_type, actual_scan_rate, synced) = hat.a_in_clock_config_read() if not synced: sleep(0.005) print('\nMCC 172 continuous scan example') print(' Functions demonstrated:') print(' mcc172.iepe_config_write') print(' mcc172.a_in_clock_config_write') print(' mcc172.a_in_clock_config_read') print(' mcc172.a_in_scan_start') print(' mcc172.a_in_scan_read') print(' mcc172.a_in_scan_stop') print(' mcc172.a_in_scan_cleanup') print(' IEPE power: ', end='') if iepe_enable == 1: print('on') else: print('off') 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, 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() # Turn off IEPE supply for channel in channels: hat.iepe_config_write(channel, 0) 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 118 functions. no_of_channels = 1 # Creates the list of channels. channels = np.ndarray.tolist(np.arange((no_of_channels), dtype=int)) channel_mask = chan_list_to_mask(channels) num_channels = len(channels) samples_per_channel = 4000 if (num_channels % 2) == 0: samples = int(samples_per_channel * num_channels) else: samples = int(mt.ceil(samples_per_channel * num_channels)) scan_rate = 4000 options = OptionFlags.DEFAULT timeout = 10.0 try: # Select an MCC 118 HAT device to use. address = select_hat_device(HatIDs.MCC_118) hat = mcc118(address) print('\nSelected MCC 118 HAT device at address', address) actual_scan_rate = hat.a_in_scan_actual_rate(num_channels, scan_rate) print('\nMCC 118 continuous scan example') print(' Functions demonstrated:') print(' mcc118.a_in_scan_start') print(' mcc118.a_in_scan_read') 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)) #try: #input('\nPress ENTER to continue ...') #except (NameError, SyntaxError): #pass # Configure and start the scan. hat.a_in_scan_start(channel_mask, samples_per_channel, scan_rate, options) print('Starting scan ... Press Ctrl-C to stop\n') """read complete output data and place int array""" read_output = hat.a_in_scan_read_numpy(samples_per_channel, timeout) """create a blank array""" chan_data = np.zeros([samples_per_channel, num_channels]) """create title array""" chan_title = [] force_data = read_output.data * 12 """iterate through the array per channel to split out every other sample into the correct column""" for i in range(num_channels): for j in range(samples_per_channel): if j == 0: y = str('Channel') + ' ' + str(i) chan_title.append(str(y)) if i < samples_per_channel - num_channels: chan_data[:, i] = force_data[i::num_channels] print('Iterated through loop\n') chan_final = np.concatenate((np.reshape(np.array(chan_title), (1, num_channels)), chan_data), axis=0) np.savetxt('foo.csv', chan_final, fmt='%5s', delimiter=',') now = datetime.datetime.now() ID = 2 Force = np.float(max(chan_data)) t1, t2 = temperature() print(Force) print(t1) print(t2) #database_upload(now, ID, Force, Temp) # Display the header row for the data table. #print('Samples Read Scan Count', end='') #for chan in channels: #print(' Channel ', chan, sep='', end='') #print('') #try: #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') except (HatError, ValueError) as err: print('\n', err)
def fswtl(): # Update Status status.config(text="Running...") status.update() i = 1 while i < 6: """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 118 functions. no_of_channels = int(chanvar.get()) # Creates the list of channels. channels = np.ndarray.tolist(np.arange((no_of_channels), dtype=int)) channel_mask = chan_list_to_mask(channels) num_channels = len(channels) samples_per_channel = int(float(totvar.get()) / 1000 * int(ratevar.get())) if (num_channels % 2) == 0: samples = int(samples_per_channel * num_channels) else: samples = int(mt.ceil(samples_per_channel * num_channels)) scan_rate = int(ratevar.get()) options = OptionFlags.EXTTRIGGER trigger_mode = TriggerModes.ACTIVE_LOW timeout = 5.0 try: # Select an MCC 118 HAT device to use. address = select_hat_device(HatIDs.MCC_118) hat = mcc118(address) print('\nSelected MCC 118 HAT device at address', address) actual_scan_rate = hat.a_in_scan_actual_rate(num_channels, scan_rate) print('\nMCC 118 continuous scan example') print(' Functions demonstrated:') print(' mcc118.trigger_mode') print(' mcc118.a_in_scan_status') print(' mcc118.a_in_scan_start') print(' mcc118.a_in_scan_read') 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) 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') status.config(text="Waiting...") status.update() wait_for_trigger(hat) print('\nStarting scan ... Press Ctrl-C to stop\n') status.config(text="Triggered") status.update() """read complete output data and place int array""" read_output = hat.a_in_scan_read_numpy(samples_per_channel, timeout) """create a blank array""" chan_data = np.zeros([samples_per_channel, num_channels]) """create title array""" chan_title = [] pressure_data = conv(read_output.data) """iterate through the array per channel to split out every other sample into the correct column""" for i in range(num_channels): for j in range(samples_per_channel): if j == 0: y = str('Channel') + ' ' + str(i) chan_title.append(str(y)) if i < samples_per_channel - num_channels: chan_data[:, i] = pressure_data[i::num_channels] print('Iterated through loop\n') chan_final = np.concatenate((np.reshape(np.array(chan_title), (1, num_channels)), chan_data), axis=0) np.savetxt('pressure.csv', chan_final, fmt='%5s', delimiter=',') now = datetime.datetime.now() ID = int(idvar.get()) PressureMax = float("{0:.2f}".format(max(pressure_data))) PressureMin = float("{0:.2f}".format(min(pressure_data))) t = temperature() Temp = t[0] print(PressureMax) print(PressureMin) print(Temp) Cyc = int(counter.get()) database_upload(now, ID, PressureMax, PressureMin, t, Cyc) hat.a_in_scan_stop() hat.a_in_scan_cleanup() # Counter stepping counter.set(counter.get() + 1) f = open('count.txt', 'w') f.write(str(counter.get())) f.close() #Plot(pressure_data) ResultsWindow(PressureMax, t) except KeyboardInterrupt: # Clear the '^C' from the display. print(CURSOR_BACK_2, ERASE_TO_END_OF_LINE, '\n') except (HatError, ValueError) as err: print('\n', err)
def main(): """ This function is executed automatically when the module is run directly. """ print("MCC 152 digital input interrupt example.") print("Enables interrupts on the inputs and displays their state when") print("they change.") print(" Functions / Methods demonstrated:") print(" mcc152.dio_reset") print(" mcc152.dio_config_write_port") print(" mcc152.dio_input_read_port") print(" mcc152.dio_int_status_read_port") print(" mcc152.info") print(" interrupt_callback_enable") print(" interrupt_callback_disable") print() # Get an instance of the selected HAT device object. address = select_hat_device(HatIDs.MCC_152) print("\nUsing address {}.\n".format(address)) global HAT # pylint: disable=global-statement HAT = mcc152(address) # Reset the DIO to defaults (all channels input, pull-up resistors # enabled). HAT.dio_reset() # Read the initial input values so we don't trigger an interrupt when # we enable them. value = HAT.dio_input_read_port() # Enable latched inputs so we know that a value changed even if it changes # back to the original value before the interrupt callback. HAT.dio_config_write_port(DIOConfigItem.INPUT_LATCH, 0xFF) # Unmask (enable) interrupts on all channels. HAT.dio_config_write_port(DIOConfigItem.INT_MASK, 0x00) print("Current input values are 0x{:02X}".format(value)) print("Waiting for changes, enter any text to exit. ") # Create a HAT callback object for our function callback = HatCallback(interrupt_callback) # Enable the interrupt callback function. Provide a mutable value for # user_data that counts the number of interrupt occurrences. int_count = [0] interrupt_callback_enable(callback, int_count) # Wait for the user to enter anything, then exit. if version_info.major > 2: input("") else: raw_input("") # Return the digital I/O to default settings. HAT.dio_reset() # Disable the interrupt callback. interrupt_callback_disable()
def __init__(self): self.sample_size = 1000 self.wf_upp_ylim = 2 self.wf_low_ylim = -2 self.rate = 10000 # pyqtgraph stuff pg.setConfigOptions(antialias=True) self.traces = dict() self.app = QtGui.QApplication(sys.argv) self.win = pg.GraphicsWindow(title='Spectrum Analyzer') self.win.setWindowTitle('Spectrum Analyzer') self.win.setGeometry(5, 115, 1910, 1070) wf_xlabels = [(0, '0'), (self.sample_size / 2, str(self.sample_size / 2)), (self.sample_size, str(self.sample_size))] wf_xaxis = pg.AxisItem(orientation='bottom') wf_xaxis.setTicks([wf_xlabels]) wf_ylabels = [(0, '0'), (self.wf_upp_ylim, str(self.wf_upp_ylim)), (self.wf_low_ylim, str(self.wf_low_ylim))] wf_yaxis = pg.AxisItem(orientation='left') wf_yaxis.setTicks([wf_ylabels]) #sp_xlabels = [ # (np.log10(10), '10'), (np.log10(100), '100'), # (np.log10(1000), '1000'), (np.log10(22050), '22050') #] sp_xlabels = [(0, '0'), (self.rate / 4, str(self.rate / 4)), (self.rate / 2, str(self.rate / 2))] sp_xaxis = pg.AxisItem(orientation='bottom') sp_xaxis.setTicks([sp_xlabels]) self.waveform = self.win.addPlot( title='WAVEFORM', row=1, col=1, axisItems={ 'bottom': wf_xaxis, 'left': wf_yaxis }, ) self.spectrum = self.win.addPlot( title='SPECTRUM', row=2, col=1, axisItems={'bottom': sp_xaxis}, ) # pyaudio stuff #self.FORMAT = pyaudio.paInt16 #self.CHANNELS = 1 #self.RATE = 44100 #self.CHUNK = 1024 * 2 self.channels = [0] self.channel_mask = chan_list_to_mask(self.channels) self.options = OptionFlags.DEFAULT self.request = self.sample_size self.timeout = 11 #self.p = pyaudio.PyAudio() #self.stream = self.p.open( # format=self.FORMAT, # channels=self.CHANNELS, # rate=self.RATE, # input=True, # output=True, # frames_per_buffer=self.CHUNK, #) # waveform and spectrum x points self.address = select_hat_device(HatIDs.MCC_118) self.hat = mcc118(self.address) #self.x = np.arange(0, 2 * self.CHUNK, 2) #self.f = np.linspace(0, self.RATE / 2, self.CHUNK / 2) self.x = np.arange(0, self.sample_size) self.f = np.linspace(0, self.rate, self.sample_size)
def main(): """ This function is executed automatically when the module is run directly. """ tc_type = TcTypes.TYPE_J # change this to the desired thermocouple type delay_between_reads = 1 # Seconds channels = (0, 1, 2, 3) try: # Get an instance of the selected hat device object. address = select_hat_device(HatIDs.MCC_134) hat = mcc134(address) for channel in channels: hat.tc_type_write(channel, tc_type) print('\nMCC 134 single data value read example') print(' Function demonstrated: mcc134.t_in_read') print(' Channels: ' + ', '.join(str(channel) for channel in channels)) print(' Thermocouple type: ' + tc_type_to_string(tc_type)) 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 Sample', end='') for channel in channels: print(' Channel', channel, end='') print('') try: samples_per_channel = 0 while True: # Display the updated samples per channel count samples_per_channel += 1 print('\r{:8d}'.format(samples_per_channel), end='') # Read a single value from each selected channel. for channel in channels: value = hat.t_in_read(channel) if value == mcc134.OPEN_TC_VALUE: print(' Open ', end='') elif value == mcc134.OVERRANGE_TC_VALUE: print(' OverRange', end='') elif value == mcc134.COMMON_MODE_TC_VALUE: print(' Common Mode', end='') else: print('{:12.2f} C'.format(value), end='') stdout.flush() # Wait the specified interval between reads. sleep(delay_between_reads) 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. """ options = OptionFlags.DEFAULT low_chan = 0 high_chan = 3 mcc_118_num_channels = mcc118.info().NUM_AI_CHANNELS sample_interval = 0.5 # Seconds try: # Ensure low_chan and high_chan are valid. if low_chan < 0 or low_chan >= mcc_118_num_channels: error_message = ('Error: Invalid low_chan selection - must be ' '0 - {0:d}'.format(mcc_118_num_channels - 1)) raise Exception(error_message) if high_chan < 0 or high_chan >= mcc_118_num_channels: error_message = ('Error: Invalid high_chan selection - must be ' '0 - {0:d}'.format(mcc_118_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_118) hat = mcc118(address) print('\nMCC 118 single data value read example') print(' Function demonstrated: mcc118.a_in_read') 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) if __name__ == '__main__': # This will only be run when the module is called directly. main()
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 118 functions. channels = [0, 1, 2, 3] channel_mask = chan_list_to_mask(channels) num_channels = len(channels) samples_per_channel = 10000 scan_rate = 1000.0 options = OptionFlags.EXTTRIGGER trigger_mode = TriggerModes.RISING_EDGE try: # Select an MCC 118 HAT device to use. address = select_hat_device(HatIDs.MCC_118) hat = mcc118(address) print('\nSelected MCC 118 HAT device at address', address) actual_scan_rate = hat.a_in_scan_actual_rate(num_channels, scan_rate) print('\nMCC 118 continuous scan example') print(' Functions demonstrated:') print(' mcc118.trigger_mode') print(' mcc118.a_in_scan_status') print(' mcc118.a_in_scan_start') print(' mcc118.a_in_scan_read') 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') except (HatError, ValueError) as err: print('\n', err)
def main(): # pylint: disable=too-many-locals, too-many-statements """ 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 172 functions. channels = [0, 1] channel_mask = chan_list_to_mask(channels) num_channels = len(channels) samples_per_channel = 10000 scan_rate = 10240.0 options = OptionFlags.EXTTRIGGER trigger_mode = TriggerModes.RISING_EDGE try: # Select an MCC 172 HAT device to use. address = select_hat_device(HatIDs.MCC_172) hat = mcc172(address) print('\nSelected MCC 172 HAT device at address', address) # Turn on IEPE supply? iepe_enable = get_iepe() for channel in channels: hat.iepe_config_write(channel, iepe_enable) # Configure the clock and wait for sync to complete. hat.a_in_clock_config_write(SourceType.LOCAL, scan_rate) synced = False while not synced: (_source_type, actual_scan_rate, synced) = hat.a_in_clock_config_read() if not synced: sleep(0.005) print('\nMCC 172 continuous scan example') print(' Functions demonstrated:') print(' mcc172.trigger_mode') print(' mcc172.a_in_clock_config_write') print(' mcc172.a_in_clock_config_read') print(' mcc172.a_in_scan_start') print(' mcc172.a_in_scan_read') print(' mcc172.a_in_scan_stop') print(' mcc172.a_in_scan_cleanup') print(' IEPE power: ', end='') if iepe_enable == 1: print('on') else: print('off') 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_config(SourceType.LOCAL, trigger_mode) # Configure and start the scan. hat.a_in_scan_start(channel_mask, samples_per_channel, 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)