def readWaveformFromAI(p_sampleRate, p_sampleSize, p_bank=Bank.A, p_channel=AIChannel.AI0, p_channelRef=None): ai_range = AIRange.PLUS_OR_MINUS_1V ai_mode = AIMode.SINGLE_ENDED isNewChannel = p_channelRef is None value_array = [] if isNewChannel: p_channelRef = AnalogInput({ 'bank': p_bank, 'channel': p_channel, 'range': ai_range, 'mode': ai_mode }) # configure the sample rate and start the acquisition p_channelRef.start_continuous_mode(p_sampleRate) printString('开始10秒录音...') # read the value timeout = -1 value_array = p_channelRef.read(p_sampleSize, timeout) printString('结束录音') # stop signal acquisition p_channelRef.stop_continuous_mode() if isNewChannel: p_channelRef.close() return value_array[0]
class Test_AnalogInput_ReadSingleChannelFromBankB(unittest.TestCase): def setUp(self): self.AI_single_channel = AnalogInput({ 'bank': bankB, 'channel': AIChannel.AI7, 'range': AIRange.PLUS_OR_MINUS_5V, 'mode': AIMode.SINGLE_ENDED }) def tearDown(self): self.AI_single_channel.close() def checkMultiplePointsReadBackValues(self, value_array, number_of_samples): value_array_for_first_channel = value_array[0][0] self.assertEqual(len(value_array_for_first_channel), number_of_samples) for value in value_array_for_first_channel: self.assertEqual(float(value), pytest.approx(3.3, 0.1)) def test_ContinuousMode_Read2222PointsWith500SampleRateAnd2000Timeout_ReturnExpectedReadBack( self): number_of_samples = 2222 sample_rate = 1200 timeout = -1 self.AI_single_channel.start_continuous_mode(sample_rate) value_array = self.AI_single_channel.read(number_of_samples, timeout) self.AI_single_channel.stop_continuous_mode() self.checkMultiplePointsReadBackValues(value_array, number_of_samples)
def test_GivenBankAAI0AI1AndBankBAI0AI1_Write_ReturnExpectedReadBack(self): def __read(number_of_times_to_read, read_object, number_of_samples_to_read, timeout, expected_value): title = {'A': 'Bank A AI0 - AO0 and AI1 - AO3', 'B': 'Bank B AI0 - AO1 and AI0 - AO3'} result = {'A': [[],[]], 'B': [[],[]]} for i in range(0, number_of_times_to_read): value_array = read_object.read(number_of_samples_to_read, timeout) # print(value_array) bank_A_values = value_array[0] bank_B_values = value_array[1] result['A'][0].append(bank_A_values[0]) result['A'][1].append(bank_A_values[1]) result['B'][0].append(bank_B_values[0]) result['B'][1].append(bank_B_values[1]) def __print(bank): print(title[bank]) for index, channel in enumerate(result[bank]): for values_per_channel in channel: values = [ round(value) for value in values_per_channel ] print('continuous: %s should almost equal to %s and continuous from the last read' % (values, expected_value[bank][index])) __print(Bank.A.value) __print(Bank.B.value) AO = AnalogOutput({'bank': Bank.B, 'channel': AOChannel.AO0}, {'bank': Bank.B, 'channel': AOChannel.AO1}, {'bank': bank, 'channel': AOChannel.AO0}, {'bank': bank, 'channel': AOChannel.AO1}) AI = AnalogInput({'bank': Bank.B, 'channel': AIChannel.AI0}, {'bank': Bank.B, 'channel': AIChannel.AI3}, {'bank': bank, 'channel': AIChannel.AI0}, {'bank': bank, 'channel': AIChannel.AI3}) timeout = -1 sample_rate = 1000 input_value = [[1,2,3,4,5,6,7,8,9,10], [10,9,8,7,6,5,4,3,2,1], [2,3,4,5,6,2,3,4,5,6], [7,6,5,4,3,7,6,5,4,3]] number_of_samples_to_read = 5 expected_value = { 'A': [self.__convert_list_to_string(input_value[2]), self.__convert_list_to_string(input_value[3])], 'B': [self.__convert_list_to_string(input_value[0]), self.__convert_list_to_string(input_value[1])] } irq_thread = threading.Thread(target=self.__writing_thread, args=(AO, input_value, timeout)) AO.start_continuous_mode(input_value, sample_rate, timeout) self.__start_thread(irq_thread) AI.start_continuous_mode(sample_rate) __read(2, AI, number_of_samples_to_read, timeout, expected_value) self.__close_thread(irq_thread) AO.close() AI.close()
def test_GivenBankAAI0AI1AndBankBAI0_WriteWithDifferentValuesLength_ReturnExpectedReadBack(self): def __read(number_of_times_to_read, read_object, number_of_samples_to_read, timeout, expected_value): # result = [A: [AO0, AO1], B: [AO0]] result = [[[],[]], [[],[]]] for i in range(0, number_of_times_to_read): value_array = read_object.read(number_of_samples_to_read, timeout) bank_A_values = value_array[0] bank_B_values = value_array[1] result[0][0].append(bank_A_values[0]) result[0][1].append(bank_A_values[1]) result[1][0].append(bank_B_values[0]) def __print(channels, bank): for channel in channels: for index, values_per_channel in enumerate(channel): values = [ round(value) for value in values_per_channel ] if bank == Bank.A.value: print('continuous: %s should almost equal to %s and continuous from the last read' % (values, expected_value[index])) else: print('continuous: %s should almost equal to %s and continuous from the last read' % (values, expected_value[2])) print('Bank A AI0 - AO0 and AI1 - AO3') __print(result[0], Bank.A.value) print('Bank B AI0 - AO0') __print(result[1], Bank.B.value) AO = AnalogOutput({'bank': Bank.B, 'channel': AOChannel.AO0}, {'bank': bank, 'channel': AOChannel.AO0}, {'bank': bank, 'channel': AOChannel.AO1}) AI = AnalogInput({'bank': Bank.B, 'channel': AIChannel.AI0}, {'bank': bank, 'channel': AIChannel.AI0}, {'bank': bank, 'channel': AIChannel.AI3}) timeout = -1 sample_rate = 1000 input_value = [[0,1,2,3,4,5,0,1,2,3,4,5], [7,8,9,10,7,8,9,10,7,8,9,10], [1,2,3,4,5,1,2,3,4,5]] number_of_samples_to_read = 4 expected_value = [self.__convert_list_to_string(input_value[1]), self.__convert_list_to_string(input_value[2]), self.__convert_list_to_string(input_value[0])] irq_thread = threading.Thread(target=self.__writing_thread, args=(AO, input_value, timeout)) AO.start_continuous_mode(input_value, sample_rate, timeout) self.__start_thread(irq_thread) AI.start_continuous_mode(sample_rate) __read(2, AI, number_of_samples_to_read, timeout, expected_value) self.__close_thread(irq_thread) AO.close() AI.close()
def test_GivenBankBAI0AndBankAAI1_Write_ReturnExpectedReadBack(self): def __read(number_of_times_to_read, read_object, number_of_samples_to_read, timeout, expected_value_for_bank_A, expected_value_for_bank_B): result = [[], []] for i in range(0, number_of_times_to_read): value_array = read_object.read(number_of_samples_to_read, timeout) result[0].append(value_array[0]) result[1].append(value_array[1]) def __print(channels, expected_value): for channel in channels: for values_per_channel in channel: values = [ round(value) for value in values_per_channel ] print('continuous: %s should almost equal to %s and continuous from the last read' % (values, expected_value)) print('Bank A AI3 - AO1') __print(result[0], expected_value_for_bank_A) print('Bank B AI0 - AO0') __print(result[1], expected_value_for_bank_B) AO = AnalogOutput({'bank': Bank.B, 'channel': AOChannel.AO0}, {'bank': bank, 'channel': AOChannel.AO1}) AI = AnalogInput({'bank': Bank.B, 'channel': AIChannel.AI0}, {'bank': bank, 'channel': AIChannel.AI3}) timeout = -1 sample_rate = 1000 input_value = [[1,2,3,4,5,6,7,8,9,10], [10,9,8,7,6,5,4,3,2,1]] number_of_samples_to_read = 5 expected_value_for_bank_B = self.__convert_list_to_string(input_value[0]) expected_value_for_bank_A = self.__convert_list_to_string(input_value[1]) irq_thread = threading.Thread(target=self.__writing_thread, args=(AO, input_value, timeout)) AO.start_continuous_mode(input_value, sample_rate, timeout) self.__start_thread(irq_thread) AI.start_continuous_mode(sample_rate) __read(2, AI, number_of_samples_to_read, timeout, expected_value_for_bank_A, expected_value_for_bank_B) self.__close_thread(irq_thread) AO.close() AI.close()
def test_ContinuousMode_StartTwoAiInSameBank_ShowAssertion(self): sample_rate = 1000 first_ai = AnalogInput({ 'bank': bankA, 'channel': AIChannel.AI2, 'range': AIRange.PLUS_OR_MINUS_10V }) second_ai = AnalogInput({ 'bank': bankA, 'channel': AIChannel.AI7, 'range': AIRange.PLUS_OR_MINUS_10V }) first_ai.start_continuous_mode(sample_rate) with self.assertRaises(AssertionError): second_ai.start_continuous_mode(sample_rate) first_ai.stop_continuous_mode() first_ai.close() second_ai.close()
def __write_and_read(input_value): AO_single_channel = AnalogOutput({'bank': Bank.B, 'channel': AOChannel.AO0}) AI_single_channel = AnalogInput({'bank': Bank.B, 'channel': AIChannel.AI0}) timeout = -1 sample_rate = 1000 number_of_samples_to_read = 10 expected_value = self.__convert_list_to_string(input_value) irq_thread = threading.Thread(target=self.__writing_thread, args=(AO_single_channel, input_value, timeout)) AO_single_channel.start_continuous_mode(input_value, sample_rate, timeout) self.__start_thread(irq_thread) AI_single_channel.start_continuous_mode(sample_rate) self.__read(2, AI_single_channel, number_of_samples_to_read, timeout, expected_value) self.__close_thread(irq_thread) AO_single_channel.close() AI_single_channel.close()
class Test_AnalogInput_StartAssertion(unittest.TestCase): def setUp(self): self.AI_single_channel = AnalogInput({ 'bank': bankA, 'channel': AIChannel.AI2, 'range': AIRange.PLUS_OR_MINUS_5V, 'mode': AIMode.SINGLE_ENDED }) self.AI_multiple_channels = AnalogInput( { 'bank': bankA, 'channel': AIChannel.AI2, 'range': AIRange.PLUS_OR_MINUS_10V }, { 'bank': bankA, 'channel': AIChannel.AI2, 'mode': AIMode.DIFFERENTIAL }) @classmethod def setUpClass(self): self.sample_rate_limits_for_multiple_channels = { 'max': 250000, 'min': 1 } def tearDown(self): self.AI_single_channel.close() self.AI_multiple_channels.close() def test_PassSampleRateThatLessThanMinToSingleChannel_ShowAssertion(self): with self.assertRaises(AssertionError): self.AI_single_channel.start_continuous_mode( limits['sampleRate']['min'] - 1) def test_PassSampleRateThatGreaterThanMaxToSingleChannel_ShowAssertion( self): with self.assertRaises(AssertionError): self.AI_single_channel.start_continuous_mode( limits['sampleRate']['max'] + 1) def test_PassSampleRateThatLessThanMinToTwoChannels_ShowAssertion(self): with self.assertRaises(AssertionError): self.AI_multiple_channels.start_continuous_mode( self.sample_rate_limits_for_multiple_channels['min'] - 1) def test_PassSampleRateThatGreaterThanMaxToTwoChannels_ShowAssertion(self): with self.assertRaises(AssertionError): self.AI_multiple_channels.start_continuous_mode( self.sample_rate_limits_for_multiple_channels['max'] + 1)
def test_Given7PointsWith1000SampleRateOnBankA_WriteThenCloseWithoutStop_ReturnExpectedReadBack(self): AO_single_channel = AnalogOutput({'bank': bank, 'channel': AOChannel.AO0}) AI_single_channel = AnalogInput({'bank': bank, 'channel': AIChannel.AI0}) timeout = -1 sample_rate = 2000 input_value = [[9,8,7,6,5,4,3,2,1,0,9,8,7,6,5,4,3,2,1,0]] number_of_samples_to_read = 7 expected_value = self.__convert_list_to_string(input_value) irq_thread = threading.Thread(target=self.__writing_thread, args=(AO_single_channel, input_value, timeout)) AO_single_channel.start_continuous_mode(input_value, sample_rate, timeout) self.__start_thread(irq_thread) AI_single_channel.start_continuous_mode(sample_rate) self.__read(3, AI_single_channel, number_of_samples_to_read, timeout, expected_value) self.__close_thread(irq_thread) AO_single_channel.close() AI_single_channel.close()
def test_ContinuousMode_ReadTwoChannelsAndCloseItThenReadAgain_ReturnExpectedReadBack( self): sample_rate = 1000 number_of_samples = 2 timeout = -1 first_ai = AnalogInput( { 'bank': bankA, 'channel': AIChannel.AI2, 'range': AIRange.PLUS_OR_MINUS_10V }, { 'bank': bankA, 'channel': AIChannel.AI2, 'mode': AIMode.DIFFERENTIAL }) second_ai = AnalogInput({ 'bank': bankB, 'channel': AIChannel.AI7, 'range': AIRange.PLUS_OR_MINUS_10V }) first_ai.start_continuous_mode(sample_rate) second_ai.start_continuous_mode(sample_rate) first_ai_value_array = first_ai.read(number_of_samples, timeout) second_ai_value_array = first_ai.read(number_of_samples, timeout) self.checkReadbankValue(first_ai_value_array[0][0], 3.3, number_of_samples) self.checkReadbankValue(first_ai_value_array[0][1], -1.7, number_of_samples) self.checkReadbankValue(second_ai_value_array[0][0], 3.3, number_of_samples) first_ai.stop_continuous_mode() second_ai.stop_continuous_mode() first_ai.close() second_ai.close() first_ai = AnalogInput( { 'bank': bankA, 'channel': AIChannel.AI2, 'range': AIRange.PLUS_OR_MINUS_10V }, { 'bank': bankA, 'channel': AIChannel.AI2, 'mode': AIMode.DIFFERENTIAL }) first_ai.start_continuous_mode(sample_rate) first_ai_value_array = first_ai.read(number_of_samples, timeout) self.checkReadbankValue(first_ai_value_array[0][0], 3.3, number_of_samples) self.checkReadbankValue(first_ai_value_array[0][1], -1.7, number_of_samples) first_ai.stop_continuous_mode() first_ai.close()
class Test_AnalogInput_ReadSingleChannelFromBankA(unittest.TestCase): def setUp(self): self.AI_single_channel = AnalogInput({ 'bank': bankA, 'channel': AIChannel.AI2, 'range': AIRange.PLUS_OR_MINUS_5V, 'mode': AIMode.SINGLE_ENDED }) def tearDown(self): self.AI_single_channel.close() def checkMultiplePointsReadBackValues(self, value_array, number_of_samples): value_array_for_first_channel = value_array[0][0] self.assertEqual(len(value_array_for_first_channel), number_of_samples) for value in value_array_for_first_channel: self.assertEqual(float(value), pytest.approx(3.3, 0.1)) def test_ReadSinglePointOnce_ReturnExpectedReadBack(self): value_array = self.AI_single_channel.read() for value in value_array: self.assertEqual(value, pytest.approx(3.3, 0.1)) def test_ReadSinglePointTwentyTimes_ReturnExpectedReadBack(self): for i in range(0, 20): value_array = self.AI_single_channel.read() for value in value_array: self.assertEqual(value, pytest.approx(3.3, 0.1)) def test_ReadZeroPointWithOneThousandSampleRate_ReturnExpectedReadBack( self): number_of_samples = limits['numberOfSamples']['min'] sample_rate = 1000 value_array = self.AI_single_channel.read(number_of_samples, sample_rate) self.checkMultiplePointsReadBackValues(value_array, number_of_samples) def test_ReadTenThousandPointsWithOneThousandSampleRate_ReturnExpectedReadBack( self): number_of_samples = limits['numberOfSamples']['max'] sample_rate = 1000 value_array = self.AI_single_channel.read(number_of_samples, sample_rate) self.checkMultiplePointsReadBackValues(value_array, number_of_samples) def test_ReadTenPointsWithOneSampleRate_ReturnExpectedReadBack(self): number_of_samples = 10 sample_rate = limits['sampleRate']['min'] value_array = self.AI_single_channel.read(number_of_samples, sample_rate) self.checkMultiplePointsReadBackValues(value_array, number_of_samples) def test_ReadTenPointsWithOneMillionSampleRate_ReturnExpectedReadBack( self): number_of_samples = 10 sample_rate = limits['sampleRate']['max'] value_array = self.AI_single_channel.read(number_of_samples, sample_rate) self.checkMultiplePointsReadBackValues(value_array, number_of_samples) def test_ContinuousMode_ReadOnePointWithOneSampleRate_ReturnExpectedReadBack( self): number_of_samples = limits['numberOfSamples']['min'] sample_rate = limits['sampleRate']['min'] timeout = -1 self.AI_single_channel.start_continuous_mode(sample_rate) value_array = self.AI_single_channel.read(number_of_samples, timeout) self.AI_single_channel.stop_continuous_mode() self.checkMultiplePointsReadBackValues(value_array, number_of_samples) def test_ContinuousMode_ReadTenKPointsWithOneMillionSampleRate_ReturnExpectedReadBack( self): number_of_samples = 10000 sample_rate = limits['sampleRate']['max'] timeout = -1 self.AI_single_channel.start_continuous_mode(sample_rate) value_array = self.AI_single_channel.read(number_of_samples, timeout) self.AI_single_channel.stop_continuous_mode() self.checkMultiplePointsReadBackValues(value_array, number_of_samples) def test_ContinuousMode_ReadTenKPointsWithFiveKSampleRateAndTwnetyOneKTimeout_ReturnExpectedReadBack( self): number_of_samples = 10000 sample_rate = 5000 timeout = 2100 self.AI_single_channel.start_continuous_mode(sample_rate) value_array = self.AI_single_channel.read(number_of_samples, timeout) self.AI_single_channel.stop_continuous_mode() self.checkMultiplePointsReadBackValues(value_array, number_of_samples) def test_ContinuousMode_ReadOnePointWithOneSampleRateAndCloseWithoutStop_ReturnExpectedReadBack( self): number_of_samples = limits['numberOfSamples']['min'] sample_rate = limits['sampleRate']['min'] timeout = -1 self.AI_single_channel.start_continuous_mode(sample_rate) value_array = self.AI_single_channel.read(number_of_samples, timeout) self.checkMultiplePointsReadBackValues(value_array, number_of_samples)
class Test_AnalogInput_ReadTwoChannelsFromBankA(unittest.TestCase): def setUp(self): self.AI_multiple_channels = AnalogInput( { 'bank': bankA, 'channel': AIChannel.AI2, 'range': AIRange.PLUS_OR_MINUS_10V }, { 'bank': bankA, 'channel': AIChannel.AI2, 'mode': AIMode.DIFFERENTIAL }) def tearDown(self): self.AI_multiple_channels.close() def checkMultiplePointsReadBackValues(self, value_array, number_of_samples): number_of_samples_for_multi_channels = number_of_samples value_array_for_first_channel = value_array[0][0] value_array_for_second_channel = value_array[0][1] self.assertEqual(len(value_array_for_first_channel), number_of_samples_for_multi_channels) self.assertEqual(len(value_array_for_second_channel), number_of_samples_for_multi_channels) for value in value_array_for_first_channel: self.assertEqual(float(value), pytest.approx(3.3, 0.1)) for value in value_array_for_second_channel: self.assertEqual(float(value), pytest.approx(-1.7, 0.1)) def test_ReadSinglePointOnce_ReturnExpectedReadBack(self): value_array = self.AI_multiple_channels.read() for index, value in enumerate(value_array): if index == 0: self.assertEqual(value, pytest.approx(3.3, 0.1)) else: self.assertEqual(value, pytest.approx(-1.7, 0.1)) def test_ReadSinglePointTwentyTimes_ReturnExpectedReadBack(self): for i in range(0, 20): value_array = self.AI_multiple_channels.read() for index, value in enumerate(value_array): if index == 0: self.assertEqual(value, pytest.approx(3.3, 0.1)) else: self.assertEqual(value, pytest.approx(-1.7, 0.1)) def test_ReadZeroPointWithOneThousandSampleRate_ReturnExpectedReadBack( self): number_of_samples = limits['numberOfSamples']['min'] sample_rate = 1000 value_array = self.AI_multiple_channels.read(number_of_samples, sample_rate) self.checkMultiplePointsReadBackValues(value_array, number_of_samples) def test_ReadTenThousandPointsWithOneThousandSampleRate_ReturnExpectedReadBack( self): number_of_samples = limits['numberOfSamples']['max'] sample_rate = 1000 value_array = self.AI_multiple_channels.read(number_of_samples, sample_rate) self.checkMultiplePointsReadBackValues(value_array, number_of_samples) def test_ReadTenPointsWithOneSampleRate_ReturnExpectedReadBack(self): number_of_samples = 10 sample_rate = limits['sampleRate']['min'] value_array = self.AI_multiple_channels.read(number_of_samples, sample_rate) self.checkMultiplePointsReadBackValues(value_array, number_of_samples) def test_ReadTenPointsWithFiveKSampleRate_ReturnExpectedReadBack(self): number_of_samples = 10 sample_rate = limits['sampleRate']['max'] / 2 value_array = self.AI_multiple_channels.read(number_of_samples, sample_rate) self.checkMultiplePointsReadBackValues(value_array, number_of_samples) def test_ContinuousMode_ReadTenPointsWith250KSampleRate_ReturnExpectedReadBack( self): number_of_samples = 10 sample_rate = 250000 timeout = -1 self.AI_multiple_channels.start_continuous_mode(sample_rate) value_array = self.AI_multiple_channels.read(number_of_samples, sample_rate) self.AI_multiple_channels.stop_continuous_mode() self.checkMultiplePointsReadBackValues(value_array, number_of_samples)