def test_mqtt(self):
loop = asyncio.get_event_loop()
s = Scheduler(loop)
sensor = make_test_output_thing_from_vallist(1, sensor_data)
mqtt_writer = MQTTWriter('localhost', topics=[
('bogus/bogus', 0),
])
sensor.to_json().connect(mqtt_writer)
s.schedule_periodic(sensor, 0.5)
mqtt_reader = MQTTReader("localhost", topics=[
('bogus/bogus', 0),
])
vs = ValidationInputThing(sensor_data, self)
mqtt_reader.take(5).select(mqtt_msg_to_unicode).from_json(constructor=SensorEvent) \
.output().connect(vs)
c = s.schedule_on_private_event_loop(mqtt_reader)
stop = StopLoopAfter(5, c)
mqtt_reader.connect(stop)
mqtt_reader.print_downstream()
sensor.print_downstream()
s.run_forever()
loop.stop()
self.assertTrue(vs.completed)
print("that's it")
def test_case(self):
"""Just run the reader in its own event loop. We stop everything after 4
events.
"""
s = Scheduler(asyncio.get_event_loop())
m = MQTTReader("localhost",
topics=[
('bogus/bogus', 0),
],
mock_class=MockMQTTClient)
m.output()
c = s.schedule_on_private_event_loop(m)
m.connect(StopLoopAfter(4, c))
m.print_downstream()
s.run_forever()
print("that's it")
def main():
parser = argparse.ArgumentParser(
description=
"Subscribe to the specified topic and write the resulting messages to Influxdb"
)
parser.add_argument(
'--mqtt-host',
type=str,
default='localhost',
help="Hostname or IP address of MQTT broker (defaults to localhost)")
parser.add_argument(
'--topic-name',
type=str,
default='sensor-data',
help="Topic for subscription (defaults to sensor-data)")
parser.add_argument('--influx-host',
type=str,
default='localhost',
help="Influx db host (defaults to localhost)")
parser.add_argument('--influx-username',
type=str,
default='root',
help="Influx db username (defaults to root)")
parser.add_argument('--influx-password',
type=str,
default=None,
help="Influx db password (defaults to None)")
parser.add_argument('--influx-database',
type=str,
default='sensor-data',
help="Influx db database (defaults to sensor-data)")
parser.add_argument('--influx-measurement',
type=str,
default='lux',
help="Influx db measurement (defaults to lux)")
args = parser.parse_args()
mqtt = setup_flow(args)
scheduler = Scheduler(asyncio.get_event_loop())
stop = scheduler.schedule_on_private_event_loop(mqtt)
print("Running main loop")
try:
scheduler.run_forever()
except KeyboardInterrupt:
print("Stopping...")
stop()
return 0
def main():
parser = argparse.ArgumentParser(
description=
"Subscribe to the specified port and write the resulting messages")
parser.add_argument('topic_name',
metavar='TOPIC_NAME',
type=str,
help="Topic for subscription")
parser.add_argument('csv_filename',
metavar="CSV_FILENAME",
type=str,
help="Name of CSV file to write with sensor data")
args = parser.parse_args()
mqtt = setup_flow(args.topic_name, args.csv_filename)
scheduler = Scheduler(asyncio.get_event_loop())
stop = scheduler.schedule_on_private_event_loop(mqtt)
print("Running main loop")
try:
scheduler.run_forever()
except KeyboardInterrupt:
print("Stopping...")
stop()
return 0
scheduler = Scheduler(asyncio.get_event_loop())
if HAS_LOCAL_SENSOR:
sensor = SensorAsOutputThing(LuxSensor(sensor_id=LOCAL_SENSOR_ID))
sensor.rolling_csv_writer(DIRECTORY, LOCAL_SENSOR_ID)
sensor.output()
scheduler.schedule_periodic_on_separate_thread(sensor, 60)
mqtt_reader = MQTTReader('localhost',
client_id='rpi',
topics=[
('remote-sensors', 0),
])
# we convert the tuple received into a SensorEvent, overwriting the timestamp.
dispatcher = mqtt_reader.map(lambda m:(m.payload).decode("utf-8"))\
.from_json()\
.map(lambda tpl: SensorEvent(sensor_id=tpl[0], ts=time.time(), val=tpl[2]))\
.dispatch(dispatch_rules)
# For each remote sensor, we create a separate csv writer
for remote in REMOTE_SENSORS:
dispatcher.rolling_csv_writer(DIRECTORY, remote, sub_port=remote).output()
dispatcher.connect(lambda x: print("Unexpected sensor %s, full event was %s" %
(x.sensor_id, x)))
#mqtt_reader.output()
mqtt_reader.print_downstream()
scheduler.schedule_on_private_event_loop(mqtt_reader)
print("Starting run...")
scheduler.run_forever()
python server_cpx.py
'''
import asyncio
import thingflow.filters.map # adds map() method
import thingflow.filters.json # adds json() method
from thingflow.base import Scheduler, SensorEvent
from thingflow.adapters.mqtt import MQTTReader
from cpx_transducer import RingInputThing, init_cpx
def setup_flow(topic):
mqtt = MQTTReader('localhost', topics=[(topic, 0),])
ring = RingInputThing()
decoded = (mqtt
.map(lambda m:(m.payload).decode('utf-8'))
.from_json(constructor=SensorEvent)
.map(lambda evt: SensorEvent(sensor_id=evt.sensor_id,
ts=evt.ts, val=int(evt.val * 255))))
decoded.output()
decoded.connect(ring)
return mqtt
init_cpx()
mqtt = setup_flow('sensor-data')
scheduler = Scheduler(asyncio.get_event_loop())
scheduler.schedule_on_private_event_loop(mqtt)
scheduler.run_forever()
