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_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 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)
