class TestBlackboard(unittest.TestCase):
def setUp(self):
self.blackboard = Blackboard()
""" Test put functionality """
def test_put(self):
# put value in buffer
self.blackboard.put_data( test_pattern, test_value )
# buffer should only contain the added value in a list
self.assertEquals( self.blackboard.get_data(test_pattern)['data'], [test_value] )
# set buffersize and add a lot of data
for pat in self.blackboard.get_patterns():
self.blackboard.set_bufsize( pat, test_buffersize )
for _ in range( 2000 ):
self.blackboard.put_data( test_pattern, randint( 0, 256 ) )
# check whether buffer size remains within buffersize
self.assertEqual( len( self.blackboard.get_data( test_pattern )['data'] ), test_buffersize )
""" Test get functionality """
def test_get(self):
# register buffer, set buffersize and add a bit of data
for pat in self.blackboard.get_patterns():
self.blackboard.set_bufferlength( test_buffersize )
for _ in range( number_of_test_samples ):
self.blackboard.put_data( test_pattern, randint( 0, 256 ) )
# buffer should contain the number of added samples
self.assertEquals( len( self.blackboard.get_data( test_pattern )['data'] ), number_of_test_samples)
def tearDown(self):
unittest.TestCase.tearDown(self)
class TestFreqSpectrum(unittest.TestCase):
def setUp(self):
unittest.TestCase.setUp(self)
self.bb = Blackboard()
pattern = '/sines'
self.offset = 10
self.frequencies = [1,3,5,7]
self.amps = [1,2,1,8]
self.gen = DataGenerator( self.bb, pattern, frequencies=self.frequencies, amplitudes=self.amps, offset=self.offset, noise=0 )
self.freqspec = FFTAnalyzer( self.bb, pattern, windowsize=256 )
self.bb.set_bufsize( '/sines/fft', 128 )
def test_fft(self):
self.gen.start()
self.freqspec.start()
sleep( 3 )
self.gen.stop()
self.freqspec.stop()
result = self.bb.get_data('/sines/fft')
# Enable when code coverage is guaranteed
#self.assertAlmostEqual( result['data'], self.offset, msg="Offset difference too big", delta=.15 )
#for f,amp in zip(self.frequencies,self.amps):
# self.assertAlmostEqual( result[f], amp, msg="Power difference too big: freq %f - original %f - measured %f" % (f, amp, result[f]), delta=.15 )
def test_setFreqBands(self):
'''
Verify if frequency bands can be set
For now only call the function for code coverage
'''
test_freq = 10
self.freqspec.setFreqBands(test_freq)
def test_setPatterns(self):
'''
Verify if patterns can be set
For now only call the function for code coverage
'''
test_pattern = '/test'
self.freqspec.setPatterns(test_pattern)
def test_resetBuffers(self):
'''
Verify if buffers can be reset
For now only call the function for code coverage
'''
self.freqspec.resetBuffers()
def tearDown(self):
unittest.TestCase.tearDown(self)
class TestDataConsumer(unittest.TestCase):
def setUp(self):
unittest.TestCase.setUp(self)
self.blackboard = Blackboard()
self.pat = '/test'
self.gen = DataGenerator( self.blackboard, self.pat, [1], [1] )
self.gen.start()
self.pat2 = '/test2'
self.gen2 = DataGenerator( self.blackboard, self.pat2, [2], [1] )
self.gen2.start()
def test_singel_data_stream(self):
"""
Test whether data of single is coming through
"""
DataConsumer( self.blackboard, self.pat )
sleep( .5 )
result = self.blackboard.get_data( self.pat )
self.assertIsNotNone( result )
self.assertGreater(len(result), 0 )
def test_multiple_data_streams(self):
DataConsumer( self.blackboard, [self.pat, self.pat2] )
sleep( .5 )
result = self.blackboard.get_data( self.pat )
self.assertIsNotNone( result )
self.assertGreater(len(result), 0 )
result = self.blackboard.get_data( self.pat2 )
self.assertIsNotNone( result )
self.assertGreater(len(result), 0 )
def tearDown(self):
unittest.TestCase.tearDown(self)
self.gen.stop()
self.gen2.stop()
class TestBlackboard(unittest.TestCase):
def setUp(self):
self.blackboard = Blackboard()
""" Test put functionality """
def test_put(self):
# put value in buffer
self.blackboard.put_data(test_pattern, test_value)
# buffer should only contain the added value in a list
self.assertEquals(
self.blackboard.get_data(test_pattern)['data'], [test_value])
# set buffersize and add a lot of data
for pat in self.blackboard.get_patterns():
self.blackboard.set_bufsize(pat, test_buffersize)
for _ in range(2000):
self.blackboard.put_data(test_pattern, randint(0, 256))
# check whether buffer size remains within buffersize
self.assertEqual(len(self.blackboard.get_data(test_pattern)['data']),
test_buffersize)
""" Test get functionality """
def test_get(self):
# register buffer, set buffersize and add a bit of data
for pat in self.blackboard.get_patterns():
self.blackboard.set_bufferlength(test_buffersize)
for _ in range(number_of_test_samples):
self.blackboard.put_data(test_pattern, randint(0, 256))
# buffer should contain the number of added samples
self.assertEquals(len(self.blackboard.get_data(test_pattern)['data']),
number_of_test_samples)
def tearDown(self):
unittest.TestCase.tearDown(self)
class TestDataConsumer(unittest.TestCase):
def setUp(self):
unittest.TestCase.setUp(self)
self.blackboard = Blackboard()
self.pat = '/test'
self.gen = DataGenerator(self.blackboard, self.pat, [1], [1])
self.gen.start()
self.pat2 = '/test2'
self.gen2 = DataGenerator(self.blackboard, self.pat2, [2], [1])
self.gen2.start()
def test_singel_data_stream(self):
"""
Test whether data of single is coming through
"""
DataConsumer(self.blackboard, self.pat)
sleep(.5)
result = self.blackboard.get_data(self.pat)
self.assertIsNotNone(result)
self.assertGreater(len(result), 0)
def test_multiple_data_streams(self):
DataConsumer(self.blackboard, [self.pat, self.pat2])
sleep(.5)
result = self.blackboard.get_data(self.pat)
self.assertIsNotNone(result)
self.assertGreater(len(result), 0)
result = self.blackboard.get_data(self.pat2)
self.assertIsNotNone(result)
self.assertGreater(len(result), 0)
def tearDown(self):
unittest.TestCase.tearDown(self)
self.gen.stop()
self.gen2.stop()
class TestFIRFilter(unittest.TestCase):
def setUp(self):
"""
Initialize blackboard and a simulation data generator
"""
unittest.TestCase.setUp(self)
self.bb = Blackboard()
self.pattern = '/sines'
self.offset = 10
self.frequencies = [50, 10]
self.amps = [1, 1]
self.gen = DataGenerator(self.bb,
self.pattern,
frequencies=self.frequencies,
amplitudes=self.amps,
offset=self.offset,
noise=0)
def test_init_notch(self):
"""
Compare the generation of notch filter coefficients with the coefficients provided by Imec
"""
notch_template = FIRPreprocessing.coefBSF256
fir = FIRFilter(self.bb, self.pattern, 129, 256, 50, 'notch')
self.assertEqual(len(notch_template), len(fir.get_coefficients()),
'sets should be equal length')
self.assertAlmostEqual(
sum([
abs(x - y)
for x, y in zip(notch_template, fir.get_coefficients())
]), 0, 5, 'difference should be small')
def test_init_lpf(self):
"""
Compare the generation of low-pass filter coefficients with the coefficients provided by Imec
"""
lpf_template = FIRPreprocessing.coefLPF256
fir = FIRFilter(self.bb, self.pattern, 33, 256, 75, 'lpf')
coef = fir.get_coefficients()
self.assertAlmostEqual(
sum([abs(x - y) for x, y in zip(lpf_template, coef)]), 0, 2,
'difference should be small')
def test_elementwise_lfilter(self):
"""
Test whether our method of elementwise processing yields the same results as processing a whole signal at once
"""
fir = FIRFilter(self.bb, self.pattern, 33, 256, 75, 'lpf')
a = 1
sig = [randint(0, 1024) for _ in range(256)]
result = lfilter(fir.get_coefficients(), a, sig, axis=0)
result2 = []
buf = []
for s in sig:
buf.append(s)
buf = buf[-33:]
result2.append(lfilter(fir.get_coefficients(), a, buf)[-1])
self.assertEqual(len(result), len(result2),
'Results should be equal length')
self.assertEqual(sum([abs(x - y) for x, y in zip(result, result2)]), 0,
'Results should be equal value')
def test_notch50(self):
"""
TODO Improve test with better timing mechanism or decouple from internal timing mechanism
When plotting the results, the filtered signal looks really good though.
"""
fir = FIRFilter(self.bb, self.pattern, 129, 256, 50, 'notch')
self.gen2 = DataGenerator(self.bb,
'/sine',
frequencies=[10],
amplitudes=[1],
offset=self.offset,
noise=0)
self.bb.set_bufsize('/sine', 512)
self.bb.set_bufsize('/sines/notch_50', 512)
self.gen.start()
self.gen2.start()
fir.start()
time.sleep(3)
self.gen.stop()
self.gen2.stop()
fir.stop()
time.sleep(1)
off = len(fir.get_coefficients())
target = self.bb.get_data('/sine')['data'][(off - 1) / 2:128 +
(off - 1) / 2]
result = self.bb.get_data('/sines/notch_50')['data'][:128]
#dif = np.average([ abs( x-y ) for x,y in zip(result, target ) ])
#delta = 1
#self.assertAlmostEqual( dif, 0, msg='Difference between target and result should be smaller than %.2f, difference is %f'%(delta,dif), delta=delta)
def test_init_pattern_no_string(self):
# An TypeError should be raised when a pattern is no string
with self.assertRaises(TypeError):
FIRFilter(self.bb, 5, 129, 256, 50, 'notch')
def test_init_not_implemented_filter(self):
# An NotImplementedError should be raised
with self.assertRaises(NotImplementedError):
FIRFilter(self.bb, self.pattern, 129, 256, 50, 'bsf')
def test_init_incompatible_filter(self):
# An TyperError should be raised
with self.assertRaises(TypeError):
FIRFilter(self.bb, self.pattern, 129, 256, 50, 'foo')
def test_init_pattern_list(self):
# For codecoverage
FIRFilter(self.bb, [self.pattern], 129, 256, 50, 'notch')
class TestFreqSpectrum(unittest.TestCase):
def setUp(self):
unittest.TestCase.setUp(self)
self.bb = Blackboard()
pattern = '/sines'
self.offset = 10
self.frequencies = [1, 3, 5, 7]
self.amps = [1, 2, 1, 8]
self.gen = DataGenerator(self.bb,
pattern,
frequencies=self.frequencies,
amplitudes=self.amps,
offset=self.offset,
noise=0)
self.freqspec = FFTAnalyzer(self.bb, pattern, windowsize=256)
self.bb.set_bufsize('/sines/fft', 128)
def test_fft(self):
self.gen.start()
self.freqspec.start()
sleep(3)
self.gen.stop()
self.freqspec.stop()
result = self.bb.get_data('/sines/fft')
# Enable when code coverage is guaranteed
#self.assertAlmostEqual( result['data'], self.offset, msg="Offset difference too big", delta=.15 )
#for f,amp in zip(self.frequencies,self.amps):
# self.assertAlmostEqual( result[f], amp, msg="Power difference too big: freq %f - original %f - measured %f" % (f, amp, result[f]), delta=.15 )
def test_setFreqBands(self):
'''
Verify if frequency bands can be set
For now only call the function for code coverage
'''
test_freq = 10
self.freqspec.setFreqBands(test_freq)
def test_setPatterns(self):
'''
Verify if patterns can be set
For now only call the function for code coverage
'''
test_pattern = '/test'
self.freqspec.setPatterns(test_pattern)
def test_resetBuffers(self):
'''
Verify if buffers can be reset
For now only call the function for code coverage
'''
self.freqspec.resetBuffers()
def tearDown(self):
unittest.TestCase.tearDown(self)
class TestFIRFilter( unittest.TestCase ):
def setUp(self):
"""
Initialize blackboard and a simulation data generator
"""
unittest.TestCase.setUp( self )
self.bb = Blackboard()
self.pattern = '/sines'
self.offset = 10
self.frequencies = [50,10]
self.amps = [1,1]
self.gen = DataGenerator( self.bb, self.pattern, frequencies=self.frequencies, amplitudes=self.amps, offset=self.offset, noise=0 )
def test_init_notch(self):
"""
Compare the generation of notch filter coefficients with the coefficients provided by Imec
"""
notch_template = FIRPreprocessing.coefBSF256
fir = FIRFilter( self.bb, self.pattern, 129, 256, 50, 'notch' )
self.assertEqual( len(notch_template), len(fir.get_coefficients() ), 'sets should be equal length')
self.assertAlmostEqual( sum([ abs( x-y ) for x,y in zip(notch_template, fir.get_coefficients() ) ]), 0, 5, 'difference should be small')
def test_init_lpf(self):
"""
Compare the generation of low-pass filter coefficients with the coefficients provided by Imec
"""
lpf_template = FIRPreprocessing.coefLPF256
fir = FIRFilter( self.bb, self.pattern, 33, 256, 75, 'lpf' )
coef = fir.get_coefficients()
self.assertAlmostEqual( sum([ abs( x-y ) for x,y in zip(lpf_template, coef ) ]), 0, 2, 'difference should be small')
def test_elementwise_lfilter(self):
"""
Test whether our method of elementwise processing yields the same results as processing a whole signal at once
"""
fir = FIRFilter( self.bb, self.pattern, 33, 256, 75, 'lpf' )
a = 1
sig = [ randint(0,1024) for _ in range(256) ]
result = lfilter( fir.get_coefficients(), a, sig, axis=0 )
result2 = []
buf = []
for s in sig:
buf.append(s)
buf = buf[-33:]
result2.append(lfilter( fir.get_coefficients(), a, buf )[-1] )
self.assertEqual( len(result), len(result2), 'Results should be equal length')
self.assertEqual( sum([ abs( x-y ) for x,y in zip(result, result2 ) ]), 0, 'Results should be equal value')
def test_notch50(self):
"""
TODO Improve test with better timing mechanism or decouple from internal timing mechanism
When plotting the results, the filtered signal looks really good though.
"""
fir = FIRFilter( self.bb, self.pattern, 129, 256, 50, 'notch' )
self.gen2 = DataGenerator( self.bb, '/sine', frequencies=[10], amplitudes=[1], offset=self.offset, noise=0 )
self.bb.set_bufsize('/sine', 512)
self.bb.set_bufsize('/sines/notch_50', 512)
self.gen.start()
self.gen2.start()
fir.start()
time.sleep( 3 )
self.gen.stop()
self.gen2.stop()
fir.stop()
time.sleep( 1 )
off = len(fir.get_coefficients())
target = self.bb.get_data('/sine')['data'][(off-1)/2:128+(off-1)/2]
result = self.bb.get_data('/sines/notch_50')['data'][:128]
#dif = np.average([ abs( x-y ) for x,y in zip(result, target ) ])
#delta = 1
#self.assertAlmostEqual( dif, 0, msg='Difference between target and result should be smaller than %.2f, difference is %f'%(delta,dif), delta=delta)
def test_init_pattern_no_string(self):
# An TypeError should be raised when a pattern is no string
with self.assertRaises(TypeError):
FIRFilter( self.bb, 5, 129, 256, 50, 'notch' )
def test_init_not_implemented_filter(self):
# An NotImplementedError should be raised
with self.assertRaises(NotImplementedError):
FIRFilter( self.bb, self.pattern, 129, 256, 50, 'bsf' )
def test_init_incompatible_filter(self):
# An TyperError should be raised
with self.assertRaises(TypeError):
FIRFilter( self.bb, self.pattern, 129, 256, 50, 'foo' )
def test_init_pattern_list(self):
# For codecoverage
FIRFilter( self.bb, [self.pattern] , 129, 256, 50, 'notch' )
