def test_OpenTwoChannelsInBankAAndThreeChannelsInBankB_HaveExpectedCnfgvalue( self): expectedResults = [{ 'bank': 'A', 'channel': AIChannel.AI0, 'cnfgval': 8 }, { 'bank': 'A', 'channel': AIChannel.AI5, 'cnfgval': 13 }, { 'bank': 'B', 'channel': AIChannel.AI3, 'cnfgval': 11 }, { 'bank': 'B', 'channel': AIChannel.AI2 + 8, 'cnfgval': 2 }, { 'bank': 'B', 'channel': AIChannel.AI4, 'cnfgval': 12 }] AI = AnalogInput({ 'bank': bankA, 'channel': AIChannel.AI0 }, { 'bank': bankB, 'channel': AIChannel.AI3 }, { 'bank': bankB, 'channel': AIChannel.AI2, 'mode': AIMode.DIFFERENTIAL }, { 'bank': bankA, 'channel': AIChannel.AI5 }, { 'bank': bankB, 'channel': AIChannel.AI4 }) AI.read() for index, channel_settings in enumerate(AI.channel_list): self.assertEqual(channel_settings['bank'], expectedResults[index]['bank']) self.assertEqual(channel_settings['channel'], expectedResults[index]['channel']) self.assertEqual(channel_settings['cnfgval'], expectedResults[index]['cnfgval']) AI.close()
def openAndCheck(bank): AI = AnalogInput({ 'bank': bank, 'channel': AIChannel.AI0 }, { 'bank': bank, 'channel': AIChannel.AI1 }, { 'bank': bank, 'channel': AIChannel.AI2 }, { 'bank': bank, 'channel': AIChannel.AI3 }, { 'bank': bank, 'channel': AIChannel.AI4 }, { 'bank': bank, 'channel': AIChannel.AI5 }, { 'bank': bank, 'channel': AIChannel.AI6 }, { 'bank': bank, 'channel': AIChannel.AI7 }, { 'bank': bank, 'channel': AIChannel.AI0, 'mode': AIMode.DIFFERENTIAL }, { 'bank': bank, 'channel': AIChannel.AI1, 'mode': AIMode.DIFFERENTIAL }, { 'bank': bank, 'channel': AIChannel.AI2, 'mode': AIMode.DIFFERENTIAL }, { 'bank': bank, 'channel': AIChannel.AI3, 'mode': AIMode.DIFFERENTIAL }) AI.read() for index, channel_settings in enumerate(AI.channel_list): self.assertEqual(channel_settings['channel'], expectedResults['channel'][index]) self.assertEqual(channel_settings['cnfgval'], expectedResults['cnfgval'][index]) AI.close()
class Test_AnalogInputAndOutput_WriteTwoChannels(unittest.TestCase): def setUp(self): self.AO_multiple_channels = AnalogOutput({'bank': bank, 'channel': AOChannel.AO0}, {'bank': bank, 'channel': AOChannel.AO1}) self.AI_multiple_channels = AnalogInput({'bank': bank, 'channel': AIChannel.AI0}, {'bank': bank, 'channel': AIChannel.AI3}) def tearDown(self): self.AO_multiple_channels.close() self.AI_multiple_channels.close() def __start_thread(self, irq_thread): irq_thread.start() self.run = True def __close_thread(self, irq_thread): self.run = False irq_thread.join() def __reading_thread(self, number_of_samples, sample_rate, expected_value): value_array = None while self.run: value_array = self.AI_multiple_channels.read(number_of_samples, sample_rate) value_array_in_bank_A = value_array[0] AI1_array = value_array_in_bank_A[0] AI3_array = value_array_in_bank_A[1] AI1_values = [ round(value) for value in AI1_array ] AI3_values = [ round(value) for value in AI3_array ] print('AO0 %s should almost equal to %s' % (AI1_values, expected_value)) print('AO3 %s should almost equal to %s' % (AI3_values, expected_value)) def test_WriteSinglePoint_ReturnExpectedReadBack(self): input_value = 3.5 self.AO_multiple_channels.write(input_value) value_array = self.AI_multiple_channels.read() for value in value_array: self.assertEqual(value, pytest.approx(input_value, 0.1)) def test_WriteSixteenPointsWithOneThousandSampleRate_ReturnExpectedReadBack(self): sample_rate = 1000 input_value = [9,9,9,9,9,9,9,9,9,9,5,5,5,2,2,2] expected_value = '9,9,9,9,9,9,9,9,9,9,5,5,5,2,2,2' irq_thread = threading.Thread(target=self.__reading_thread, args=(len(input_value), sample_rate, expected_value)) self.__start_thread(irq_thread) self.AO_multiple_channels.write(input_value, sample_rate) self.__close_thread(irq_thread)
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_WriteSinglePoint_ReturnDifferentValueFromEachChannel(self): AO_multiple_channels = AnalogOutput({'bank': bank, 'channel': AOChannel.AO0}, {'bank': bank, 'channel': AOChannel.AO1}) AI_multiple_channels = AnalogInput({'bank': bank, 'channel': AIChannel.AI0}, {'bank': bank, 'channel': AIChannel.AI3}) input_value_for_single_channels = 2.5 input_value_for_multiple_channels = 3.3 AO_multiple_channels.write(input_value_for_multiple_channels) self.AO_single_channel.write(input_value_for_single_channels) value_array = AI_multiple_channels.read() for index, value in enumerate(value_array): if index == 0: self.assertEqual(value, pytest.approx(input_value_for_single_channels, 0.1)) else: self.assertEqual(value, pytest.approx(input_value_for_multiple_channels, 0.1)) AO_multiple_channels.close() AI_multiple_channels.close()
class Test_AnalogInputAndOutput_WriteSingleChannel(unittest.TestCase): def setUp(self): self.AO_single_channel = AnalogOutput({'bank': bank, 'channel': AOChannel.AO0}) self.AI_single_channel = AnalogInput({'bank': bank, 'channel': AIChannel.AI0}) def tearDown(self): self.AO_single_channel.close() self.AI_single_channel.close() def __start_thread(self, irq_thread): irq_thread.start() self.run = True def __close_thread(self, irq_thread): self.run = False irq_thread.join() def __reading_thread(self, read_object, number_of_samples, sample_rate, expected_value): value_array = None while self.run: value_array = read_object.read(number_of_samples, sample_rate)[0][0] values = [ round(value) for value in value_array ] print('%s should almost equal to %s' % (values, expected_value)) def test_WriteSinglePoint_ReturnExpectedReadBack(self): input_value = 2.0 self.AO_single_channel.write(input_value) value_array = self.AI_single_channel.read() for value in value_array: self.assertEqual(value, pytest.approx(input_value, 0.1)) def test_WriteSinglePoint_ReturnDifferentValueFromEachChannel(self): AO_multiple_channels = AnalogOutput({'bank': bank, 'channel': AOChannel.AO0}, {'bank': bank, 'channel': AOChannel.AO1}) AI_multiple_channels = AnalogInput({'bank': bank, 'channel': AIChannel.AI0}, {'bank': bank, 'channel': AIChannel.AI3}) input_value_for_single_channels = 2.5 input_value_for_multiple_channels = 3.3 AO_multiple_channels.write(input_value_for_multiple_channels) self.AO_single_channel.write(input_value_for_single_channels) value_array = AI_multiple_channels.read() for index, value in enumerate(value_array): if index == 0: self.assertEqual(value, pytest.approx(input_value_for_single_channels, 0.1)) else: self.assertEqual(value, pytest.approx(input_value_for_multiple_channels, 0.1)) AO_multiple_channels.close() AI_multiple_channels.close() def test_WriteTensPointWithOneThousandSampleRate_ReturnExpectedReadBack(self): sample_rate = 1000 input_value = [1,1,2,2,3,3,4,4,5,5] expected_value = '1,1,2,2,3,3,4,4,5,5' irq_thread = threading.Thread(target=self.__reading_thread, args=(self.AI_single_channel, len(input_value), sample_rate, expected_value)) self.__start_thread(irq_thread) self.AO_single_channel.write(input_value, sample_rate) self.__close_thread(irq_thread) def test_WriteTenPointsThenWriteSinglePointInBankB_ReturnExpectedReadBack(self): AO0 = AnalogOutput({'bank': Bank.B, 'channel': AOChannel.AO0}) AI0 = AnalogInput({'bank': Bank.B, 'channel': AIChannel.AI0}) def __multipleWriteAndRead(): sample_rate = 1000 input_value = [7,7,7,7,7,7,7,5,5,10] expected_value = '7,7,7,7,7,7,7,5,5,10' irq_thread = threading.Thread(target=self.__reading_thread, args=(AI0, len(input_value), sample_rate, expected_value)) self.__start_thread(irq_thread) AO0.write(input_value, sample_rate) self.__close_thread(irq_thread) def __singleWriteAndRead(): input_value = 3.2 AO0.write(input_value) value = AI0.read()[0] self.assertEqual(value, pytest.approx(input_value, 0.1)) __multipleWriteAndRead() __singleWriteAndRead() AO0.close() AI0.close()
class Test_AnalogInput_ReadAssertion(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.approx_number_of_samples = 10 self.approx_samples_rate = 1000 def tearDown(self): self.AI_single_channel.close() self.AI_multiple_channels.close() def test_PassOneArgumentToReadOneChannel_ShowAssertion(self): with self.assertRaises(TypeError): self.AI_single_channel.read(10) def test_PassThreeArgumentsToReadOneChannel_ShowAssertion(self): with self.assertRaises(TypeError): self.AI_single_channel.read(10, 10, 10) def test_PassNumberOfSamplesThatGreaterThanMaxToReadOneChannel_ShowAssertion( self): with self.assertRaises(AssertionError): self.AI_single_channel.read(limits['numberOfSamples']['max'] + 1, self.approx_samples_rate) def test_PassNumberOfSamplesThatLessThanMinToReadOneChannel_ShowAssertion( self): with self.assertRaises(AssertionError): self.AI_single_channel.read(limits['numberOfSamples']['min'] - 1, self.approx_samples_rate) def test_PassMaxSampleRateToReadTwoChannels_ShowAssertion(self): with self.assertRaises(AssertionError): self.AI_multiple_channels.read(self.approx_number_of_samples, limits['sampleRate']['max']) def test_PassSampleRateThatGreaterThanMaxToReadOneChannel_ShowAssertion( self): with self.assertRaises(AssertionError): self.AI_single_channel.read(self.approx_number_of_samples, limits['sampleRate']['max'] + 1) def test_PassSampleRateThatLessThanMinToReadOneChannel_ShowAssertion(self): with self.assertRaises(AssertionError): self.AI_single_channel.read(self.approx_number_of_samples, limits['sampleRate']['min'] - 1)
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_OpenTwoNsampleAtTheSameTime(unittest.TestCase): def open_first_ai(self): self.first_ai = AnalogInput( { 'bank': bankA, 'channel': AIChannel.AI2, 'range': AIRange.PLUS_OR_MINUS_10V }, { 'bank': bankA, 'channel': AIChannel.AI2, 'mode': AIMode.DIFFERENTIAL }) def open_second_ai(self): self.second_ai = AnalogInput({ 'bank': bankA, 'channel': AIChannel.AI6, 'range': AIRange.PLUS_OR_MINUS_10V }) def close_first_ai(self): self.first_ai.close() def close_second_ai(self): self.second_ai.close() def checkReadbankValue(self, value_array, expected_value, expected_number_of_samples): self.assertEqual(len(value_array), expected_number_of_samples) for value in value_array: self.assertEqual(float(value), pytest.approx(expected_value, 0.1)) def test_ReadTwoAiNsampleAndCloseItThenReadAgain_ReturnExpectedReadBack( self): number_of_samples = 100 sample_rate = 1000 self.open_first_ai() self.open_second_ai() first_ai_value_array = self.first_ai.read(number_of_samples, sample_rate) second_ai_value_array = self.second_ai.read(number_of_samples, sample_rate) 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], 5, number_of_samples) self.close_first_ai() self.close_second_ai() self.open_first_ai() first_ai_value_array = self.first_ai.read(number_of_samples, sample_rate) 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.close_first_ai()
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)