def test_OpenBCISource(self):
options = {"rabbitmq_address": self.rabbitmq_address,
"rabbitmq_user": self.rabbitmq_user,
"rabbitmq_pwd": self.rabbitmq_pwd,
"rabbitmq_vhost": self.rabbitmq_vhost}
publisher = PikaPublisher(self.base_routing_key, **options)
publisher.connect()
publisher.register(self.metric_name, self.num_channels,
self.buffer_size)
publishers = [publisher]
subscribers = []
source = OpenBCISource(subscribers=subscribers,
publishers=publishers,
port=self.port,
baud=self.baud,
filter_data=self.filter_data)
source.start()
pub = source.publishers[0]
routing_key = "%s:%s" % (self.base_routing_key, self.metric_name)
self.assertEqual(pub.channels[routing_key].published_count, 0)
self.assertEqual(pub.channels[routing_key].message_published,
None, "No messages should have been sent yet.")
def test_PikaPublisher(self):
options = {"rabbitmq_address": self.rabbitmq_address,
"rabbitmq_user": self.rabbitmq_user,
"rabbitmq_pwd": self.rabbitmq_pwd}
publisher = PikaPublisher(self.base_routing_key, **options)
publisher.connect()
publisher.register(self.metric_name, self.num_channels, self.buffer_size)
for metric_name in publisher.get_metrics_to_num_channels().keys():
routing_key = "%s:%s" % (self.base_routing_key, metric_name)
self.assertEqual(publisher.channels[routing_key].published_count, 0)
self.assertEqual(publisher.channels[routing_key].message_published,
None)
publisher.publish(metric_name, self.message)
self.assertEqual(publisher.channels[routing_key].published_count, 0)
publisher.publish(metric_name, self.message)
self.assertEqual(publisher.channels[routing_key].published_count, 1)
expectedMessage = json.dumps([{
"channel_5": 5, "channel_4": 4, "channel_7": 7,
"channel_6": 6, "channel_1": 1, "channel_0": 0,
"channel_3": 3, "channel_2": 2, "timestamp": 100
}, {
"channel_5": 5, "channel_4": 4, "channel_7": 7,
"channel_6": 6, "channel_1": 1, "channel_0": 0,
"channel_3": 3, "channel_2": 2, "timestamp": 100
}])
self.assertEqual(publisher.channels[routing_key].message_published,
expectedMessage)
def main():
# Sine wave params
alpha_amplitude = 10.0
alpha_freq = 10.0
beta_amplitude = 5.0
beta_freq = 25.0
notch_amplitude = 10.0
notch_freq = 60.0 # Simulate ambiant electrical noise
# Mock data generator (sine wave)
sampling_frequency = 250.0 # 1/250 = 0.004 s
number_points = 250
signal = sine_wave(number_points, sampling_frequency, alpha_amplitude,
alpha_freq, beta_amplitude, beta_freq, notch_amplitude,
notch_freq)
data = signal_generator(num_channels, sampling_frequency, signal)
# Setup the publisher
publisher = PikaPublisher(base_routing_key=base_routing_key,
rabbitmq_address=rabbitmq_address,
rabbitmq_user=rabbitmq_user,
rabbitmq_pwd=rabbitmq_pwd)
publisher.connect()
publisher.register(metric_name, num_channels, buffer_size)
# Publish data
print "Publishing data ..."
try:
for datapoint in data:
publisher.publish(metric_name, datapoint)
except KeyboardInterrupt:
publisher.disconnect()
time.sleep(0.1)
sys.exit(0)
def main():
# Sine wave params
alpha_amplitude = 10.0
alpha_freq = 10.0
beta_amplitude = 5.0
beta_freq = 25.0
notch_amplitude = 10.0
notch_freq = 60.0 # Simulate ambiant electrical noise
# Mock data generator (sine wave)
sampling_frequency = 250.0 # 1/250 = 0.004 s
number_points = 250
signal = sine_wave(number_points, sampling_frequency, alpha_amplitude, alpha_freq,
beta_amplitude, beta_freq, notch_amplitude, notch_freq)
data = signal_generator(num_channels, sampling_frequency, signal)
# Setup the publisher
publisher = PikaPublisher(base_routing_key=base_routing_key,
rabbitmq_address=rabbitmq_address,
rabbitmq_user=rabbitmq_user,
rabbitmq_pwd=rabbitmq_pwd)
publisher.connect()
publisher.register(metric_name, num_channels, buffer_size)
# Publish data
print "Publishing data ..."
try:
for datapoint in data:
publisher.publish(metric_name, datapoint)
except KeyboardInterrupt:
publisher.disconnect()
time.sleep(0.1)
sys.exit(0)
def test_OpenBCISource(self):
options = {
"rabbitmq_user": self.rabbitmq_user,
"rabbitmq_pwd": self.rabbitmq_pwd
}
publisher = PikaPublisher(self.base_routing_key, **options)
publisher.connect()
publisher.register(self.metric_name, self.num_channels,
self.buffer_size)
publishers = [publisher]
subscribers = []
source = OpenBCISource(subscribers=subscribers,
publishers=publishers,
port=self.port,
baud=self.baud,
filter_data=self.filter_data)
source.start()
pub = source.publishers[0]
routing_key = "%s:%s" % (self.base_routing_key, self.metric_name)
self.assertEqual(pub.channels[routing_key].published_count, 0)
self.assertEqual(pub.channels[routing_key].message_published, None,
"No messages should have been sent yet.")
def main():
# Message to send
message = {'timestamp': 100}
for i in range(num_channels):
message['channel_%s' % i] = i
# Setup the publisher
publisher = PikaPublisher(base_routing_key=base_routing_key,
rabbitmq_address=rabbitmq_address,
rabbitmq_user=rabbitmq_user,
rabbitmq_pwd=rabbitmq_pwd)
publisher.connect()
publisher.register(metric_name, num_channels, buffer_size)
# Publish data
print "Publishing data ..."
publish = True
while publish:
try:
publisher.publish(metric_name, message)
time.sleep(0.001)
except KeyboardInterrupt:
publish = False
publisher.disconnect()
def main():
# Message to send
message = {'timestamp': 100}
for i in range(num_channels):
message['channel_%s' % i] = i
# Setup the publisher
publisher = PikaPublisher(base_routing_key=base_routing_key,
rabbitmq_address=rabbitmq_address,
rabbitmq_user=rabbitmq_user,
rabbitmq_pwd=rabbitmq_pwd)
publisher.connect()
publisher.register(metric_name, num_channels, buffer_size)
# Publish data
print "Publishing data ..."
publish = True
while publish:
try:
publisher.publish(metric_name, message)
time.sleep(0.001)
except KeyboardInterrupt:
publish = False
publisher.disconnect()
def test_PikaPublisher(self):
options = {
"rabbitmq_address": self.rabbitmq_address,
"rabbitmq_user": self.rabbitmq_user,
"rabbitmq_pwd": self.rabbitmq_pwd
}
publisher = PikaPublisher(self.base_routing_key, **options)
publisher.connect()
publisher.register(self.metric_name, self.num_channels,
self.buffer_size)
for metric_name in publisher.get_metrics_to_num_channels().keys():
routing_key = "%s:%s" % (self.base_routing_key, metric_name)
self.assertEqual(publisher.channels[routing_key].published_count,
0)
self.assertEqual(publisher.channels[routing_key].message_published,
None)
publisher.publish(metric_name, self.message)
self.assertEqual(publisher.channels[routing_key].published_count,
0)
publisher.publish(metric_name, self.message)
self.assertEqual(publisher.channels[routing_key].published_count,
1)
expectedMessage = json.dumps([{
"channel_5": 5,
"channel_4": 4,
"channel_7": 7,
"channel_6": 6,
"channel_1": 1,
"channel_0": 0,
"channel_3": 3,
"channel_2": 2,
"timestamp": 100
}, {
"channel_5": 5,
"channel_4": 4,
"channel_7": 7,
"channel_6": 6,
"channel_1": 1,
"channel_0": 0,
"channel_3": 3,
"channel_2": 2,
"timestamp": 100
}])
self.assertEqual(publisher.channels[routing_key].message_published,
expectedMessage)
