def test_read_mqtt_multi_device_abstract(self, fix_registered):
"Test add/remove devices dynamically and read their data."
import time
from relayr import Client
from relayr.resources import Device
from relayr.dataconnection import MqttStream
fixture = fix_registered.testset1
c = Client(token=fixture['token'])
# create channel with one device (microphone)
mic = Device(id=fixture['deviceID'], client=c)
stream = MqttStream(self.receive, [mic])
stream.start()
time.sleep(5)
# add one device (temperature/humidity)
temphum = Device(id=fixture['deviceID2'], client=c)
stream.add_device(temphum)
time.sleep(5)
# remove one device (microphone)
stream.remove_device(mic)
time.sleep(5)
stream.stop()
def relayr_configure(self):
from relayr import Client
from relayr.dataconnection import MqttStream
self.client = Client(token=self.relayr_config["token"])
self.devices = {
self.client.get_device(id=device['id']): device['name']
for device in self.relayr_config["devices"]
}
self.mqtt_stream = MqttStream(self.mqtt_callback, self.devices.keys())
class RelayrService:
def __init__(self, token, deviceId):
# device 'fe4bb3e0-400f-48fa-aac0-0c2713a92827'
#token 'FvhcUVcNkTsHqg4qI1w3wVs-Gadryj8O'
self.client = Client(token=token)
self.device = self.client.get_device(id=deviceId)
def startStream(self, callback):
self.stream = MqttStream(callback, [self.device])
self.stream.start()
def stopStream(self):
self.stream.stop()
def main():
"Get some current sensor values from a prototype."
# Use token from your relayr API keys page.
# *** REPLACE WITH YOUR OWN! ***
c = Client(token='kKSWtiYvfFoTHD1RY-d7Lif4tPRhUKgU')
dev = c.get_device(id=creds['user'])
def mqtt_callback(topic, payload):
print json.loads(payload)['readings']
stream = MqttStream(mqtt_callback, [dev])
stream.start()
time.sleep(10)
stream.stop()
class RelayrSensorApp(App):
def __init__(self, **kwargs):
super(RelayrSensorApp, self).__init__(**kwargs)
from kivy.storage.jsonstore import JsonStore
self.relayr_config = JsonStore('relayr_credentials.json')
self.relayr_configure()
def mqtt_callback(self, topic, payload):
self.root.update(topic, payload)
def relayr_configure(self):
from relayr import Client
from relayr.dataconnection import MqttStream
self.client = Client(token=self.relayr_config["token"])
self.devices = {self.client.get_device(id=device['id']): device['name'] for device in
self.relayr_config["devices"]}
self.mqtt_stream = MqttStream(self.mqtt_callback, self.devices.keys())
def on_start(self):
self.mqtt_stream.start()
def on_pause(self):
self.mqtt_stream.stop()
def on_resume(self):
self.mqtt_stream.start()
def on_stop(self):
self.mqtt_stream.stop()
def build(self):
from widgets import MainWidget
return MainWidget(self.devices)
def relayr_configure(self):
from relayr import Client
from relayr.dataconnection import MqttStream
self.client = Client(token=self.relayr_config["token"])
self.devices = {self.client.get_device(id=device['id']): device['name'] for device in
self.relayr_config["devices"]}
self.mqtt_stream = MqttStream(self.mqtt_callback, self.devices.keys())
def connect():
"Connect to a device and read data until interrupted by CTRL+C."
DSN = 'DSN=' + ODBC_DSN
if ODBC_USER:
DSN += ';UID=' + ODBC_USER
if ODBC_PASSWORD:
DSN += ';PWD=' + ODBC_PASSWORD
# Connect to dtabase.
cnxn = pyodbc.connect(DSN)
cursor = cnxn.cursor()
print("Connected to database")
try:
# Check if database table already exists.
cursor.execute("SELECT id, time, sensor, value FROM wunderdata")
except: # catch all
cursor.execute("""
CREATE TABLE wunderdata (
id INT NOT NULL AUTO_INCREMENT,
device CHAR(40) NOT NULL,
sensor CHAR(20) NOT NULL,
time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
value float NOT NULL,
PRIMARY KEY (id),
KEY data (device, sensor, time)
)""")
cursor.commit()
c = Client(token=ACCESS_TOKEN)
device = Device(id=SENSOR_ID, client=c).get_info()
callbacks = Callbacks(device, cursor)
print("Monitoring '%s' (%s) ..." % (device.name, device.id))
try:
# Loop until interrupted by keyboard.
while True:
stream = MqttStream(callbacks.sensor, [device], transport='mqtt')
stream.start()
time.sleep(10)
stream.stop()
except KeyboardInterrupt:
print('')
stream.stop()
print("Stopped")
# Close database connection.
cnxn.close()
def connect():
"Connect to a device and read data until interrupted by CTRL+C."
DSN = 'DSN=' + ODBC_DSN
if ODBC_USER:
DSN += ';UID=' + ODBC_USER
if ODBC_PASSWORD:
DSN += ';PWD=' + ODBC_PASSWORD
# Connect to dtabase.
cnxn = pyodbc.connect(DSN)
cursor = cnxn.cursor()
print("Connected to database")
try:
# Check if database table already exists.
cursor.execute("SELECT id, time, sensor, value FROM wunderdata")
except: # catch all
cursor.execute("""
CREATE TABLE wunderdata (
id INT NOT NULL AUTO_INCREMENT,
device CHAR(40) NOT NULL,
sensor CHAR(20) NOT NULL,
time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
value float NOT NULL,
PRIMARY KEY (id),
KEY data (device, sensor, time)
)""" )
cursor.commit()
c = Client(token=ACCESS_TOKEN)
device = Device(id=SENSOR_ID, client=c).get_info()
callbacks = Callbacks(device, cursor)
print("Monitoring '%s' (%s) ..." % (device.name, device.id))
try:
# Loop until interrupted by keyboard.
while True:
stream = MqttStream(callbacks.sensor, [device], transport='mqtt')
stream.start()
time.sleep(10)
stream.stop()
except KeyboardInterrupt:
print('')
stream.stop()
print("Stopped")
# Close database connection.
cnxn.close()
def connect():
"Connect to a device and read data for some time."
c = Client(token=ACCESS_TOKEN)
mic = Device(id=MICROPHONE_ID, client=c).get_info()
callbacks = Callbacks(mic)
print("Monitoring '%s' (%s) for 60 seconds..." % (mic.name, mic.id))
stream = MqttStream(callbacks.microphone, [mic], transport='mqtt')
stream.start()
try:
time.sleep(60)
except KeyboardInterrupt:
print('')
stream.stop()
print("Stopped")
class RelayrSensorApp(App):
def __init__(self, **kwargs):
super(RelayrSensorApp, self).__init__(**kwargs)
from kivy.storage.jsonstore import JsonStore
self.relayr_config = JsonStore('relayr_credentials.json')
self.relayr_configure()
def mqtt_callback(self, topic, payload):
self.root.update(topic, payload)
def relayr_configure(self):
from relayr import Client
from relayr.dataconnection import MqttStream
self.client = Client(token=self.relayr_config["token"])
self.devices = {
self.client.get_device(id=device['id']): device['name']
for device in self.relayr_config["devices"]
}
self.mqtt_stream = MqttStream(self.mqtt_callback, self.devices.keys())
def on_start(self):
self.mqtt_stream.start()
def on_pause(self):
self.mqtt_stream.stop()
def on_resume(self):
self.mqtt_stream.start()
def on_stop(self):
self.mqtt_stream.stop()
def build(self):
from widgets import MainWidget
return MainWidget(self.devices)
def test_read_mqtt_single_device_short(self, fix_registered):
"Test connect to a single device via MQTT and read data."
import time
from relayr import Client
from relayr.resources import Device
from relayr.dataconnection import MqttStream
token = fix_registered.testset1['token']
c = Client(token=token)
deviceId = fix_registered.testset1['deviceID']
dev = Device(id=deviceId, client=c)
received = []
def callback(topic, payload):
received.append((topic, payload))
conn = MqttStream(callback, [dev], transport='mqtt')
conn.start()
time.sleep(10)
conn.stop()
# dev.delete_channel(creds['channelId'])
assert len(received) > 0
def startStream(self, callback):
self.stream = MqttStream(callback, [self.device])
self.stream.start()
# convert to human readable time
human_time = datetime.datetime.fromtimestamp(
int(time) / 1000).strftime('%Y-%m-%d %H:%M:%S')
print('%s: %s' % (human_time, temp))
# print('%s %s' % (topic, payload))
# write to plotly stream
s.write(dict(x=human_time, y=temp))
# open plotly stream with the stream_id
s = py.Stream(stream_id)
s.open()
# open relayr mqtt connection
stream = MqttStream(mqtt_callback, [dev])
stream.start()
# loop until ctrl-c
try:
while True:
time.sleep(10)
except KeyboardInterrupt:
# close relayr stream
print('closing relayr stream')
stream.stop()
# close plotly stream
print('closing plotly stream')
s.close()
except ImportError:
import simplejson as json
with open('apikeys.txt', 'r') as keyFile:
keyFile = open('apikeys.txt', 'r')
CLIENT_TOKEN = keyFile.readline().rstrip()
DEVICE_ID = keyFile.readline().rstrip()
keyFile.closed
c = Client(token=CLIENT_TOKEN)
dev = c.get_device(id=DEVICE_ID)
def mqtt_callback(topic, payload):
print('%s %s' % (topic, payload))
stream = MqttStream(mqtt_callback, [dev])
stream.start()
time.sleep(10)
stream.stop()
#example code where I scraped json to see how to do that
# sound = twitter.statuses.user_timeline.tweets(screen_name="amandapalmer", since_id = int(readData),
# exclude_replies = "true", include_rts = "false")
#
# #step through list of last tweets
# for i in lastTweets:
# #strip the text out of the json of the tweet
# thisTweet = i['text']
