def poll(sensor, results):
"""
Polls a RuuviTag using BT
Returns:
True
"""
tag_instance = RuuviTag(sensor.mac)
# update state from the device
state = tag_instance.update()
if state:
# populate the sensor results
if state.get('temperature'):
results.set_result(sensor, 'temperature', state['temperature'])
if state.get('humidity'):
results.set_result(sensor, 'humidity', state['humidity'])
if state.get('pressure'):
results.set_result(sensor, 'pressure', state['pressure'])
if state.get('identifier'):
# This is NOT the configured NAME
results.set_result(sensor, 'identifier', state['identifier'])
else:
results.inactive_sensors.append(sensor)
return True
def read_tag(tag_mac, device):
"""Read data from the RuuviTag with the provided MAC address.
Returns a dictionary containing the data."""
sensor = RuuviTag(tag_mac, bt_device=device)
sensor.update()
# get latest state (does not get it from the device)
return sensor.state
def ruuviScan():
sensor = RuuviTag(sensor_mac)
state = sensor.update()
json_str = '{"uid": "' + str(sensor_mac) + '", "payload": ' + json.dumps(
state) + '}'
print(json_str)
sender.send_message(json_str)
time.sleep(2)
def test_tag_update_is_valid(self):
tag = RuuviTag('48:2C:6A:1E:59:3D')
state = tag.state
self.assertEqual(state, {})
state = tag.update()
self.assertEqual(state['temperature'], 24)
self.assertEqual(state['pressure'], 995)
self.assertEqual(state['humidity'], 30)
def read_data():
global cachedData
allData = []
try:
for mac in configuredTags.keys():
sensor = RuuviTag(mac)
sensor.update()
tagData = sensor.state
tagData['name'] = configuredTags[mac]
allData.append(tagData)
except:
sys.exit(1)
cachedData.clear()
return allData
def _setup(self):
from ruuvitag_sensor.ruuvitag import RuuviTag
_LOGGER.info("Adding %d %s devices", len(self.devices), repr(self))
for name, mac in self.devices.items():
_LOGGER.debug("Adding %s device '%s' (%s)", repr(self), name, mac)
self.devices[name] = RuuviTag(mac)
def test_tag_correct_properties(self):
org_mac = 'AA:2C:6A:1E:59:3D'
tag = RuuviTag(org_mac)
mac = tag.mac
state = tag.state
self.assertEqual(mac, org_mac)
self.assertEqual(state, {})
def log_reading(mac, logfile=None):
"""Reads the state of a Ruubitag and writes it into a logfile if provided.
The logfile is created if it doesn't already exist.
# Arguments
mac: str. MAC-address of the ruuvitag
logfile: str or None (default None). Path to the logfile. If `None`,
the reading is just returned and nothing gets logged.
"""
sensor = RuuviTag(mac)
sensor.update()
reading = sensor.state
reading['time'] = str(datetime.datetime.now())
if logfile:
maybe_create_log(logfile)
with open(logfile, 'a', newline='\n') as f:
dw = csv.DictWriter(f, fieldnames=_fields, extrasaction='ignore')
dw.writerow(reading)
return reading
def __init__(self):
self.ruuviSensors.insert(0, RuuviTag('FB:9C:C6:4D:2C:46'))
self.ruuviSensors.insert(1, RuuviTag('D1:82:DB:D5:46:1D'))
self.ruuviSensors.insert(2, RuuviTag('C6:BD:CC:FA:58:1C'))
self.ruuviSensors.insert(3, RuuviTag('DC:1F:FE:DA:57:36'))
self.ruuviSensors.insert(4, RuuviTag('EC:E0:88:7D:3B:66'))
self.ruuviSensors.insert(5, RuuviTag('EC:D4:41:5A:82:BC'))
from ruuvitag_sensor.ruuvitag import RuuviTag
sensor = RuuviTag('E0:7F:A8:07:C2:36')
# update state from the device
state = sensor.update()
print(state)
# get latest state (does not get it from the device)
state = sensor.state
print(state["pressure"])
# -*- coding: utf-8 -*-
"""
Created on Thu Dec 10 09:33:37 2020
@author: jorge
"""
from ruuvitag_sensor.ruuvitag import RuuviTag
#sensor = RuuviTag('AA:2C:6A:1E:59:3D')
sensor = RuuviTag('C4:4F:33:65:D2:4B')
# update state from the device
state = sensor.update()
# get latest state (does not get it from the device)
state = sensor.state
print(state)
def test_false_mac_raise_error(self):
with self.assertRaises(ValueError):
RuuviTag('48:2C:6A:1E')
con.close()
print('insert ruuvitagdata database')
# Change here your own device's mac-address
tagList = [
'F6:DB:7F:5E:C8:62', 'F1:15:2E:FC:0C:3A', 'EF:28:0A:7D:E1:1D',
'E9:7A:A6:0B:51:1E', 'F0:DE:F8:93:AF:A2'
]
print('Starting')
tz = pytz.timezone('Europe/Helsinki')
while True:
for tag in tagList:
sensor = RuuviTag(tag)
data = sensor.update()
insertRuuvitagData(data['temperature'], data['pressure'],
data['humidity'], tag,
datetime.now(tz=tz).strftime('%Y-%m-%d %H:%M'))
print(tag)
# Wait for 60 seconds and start over again
try:
time.sleep(300)
except KeyboardInterrupt:
# When Ctrl+C is pressed execution of the while loop is stopped
print('Exit')
break
from ruuvitag_sensor.ruuvitag import RuuviTag
import os
import datetime
import time
sensor = RuuviTag('D7:05:12:28:73:D9')
i = 0
while 1:
print(i)
i = i + 1
# update state from the device
state = sensor.update()
# get latest state (does not get it from the device)
state = sensor.state
for var in state:
print(var + " : " + str(state[var]))
date = datetime.datetime.now()
print("Ano : " + str(date.year))
print("Mês : " + str(date.month))
print("dia : " + str(date.day))
print("hora : " + str(date.hour))
print("minuto : " + str(date.minute))
print("segundo : " + str(date.second))
print("\n\n--------------------------\n\n")
help='Stream broadcasts from all RuuviTags')
parser.add_argument('--version',
action='version',
version='%(prog)s {}'.format(
ruuvitag_sensor.__version__))
parser.add_argument('--debug',
action='store_true',
dest='debug_action',
help='Enable debug logging')
args = parser.parse_args()
if args.debug_action:
log.setLevel(logging.DEBUG)
for handler in log.handlers:
handler.setLevel(logging.DEBUG)
if args.mac_address:
sensor = RuuviTag(args.mac_address, args.bt_device)
state = sensor.update()
log.info(state)
elif args.find_action:
RuuviTagSensor.find_ruuvitags(args.bt_device)
elif args.latest_action:
datas = RuuviTagSensor.get_data_for_sensors(bt_device=args.bt_device)
log.info(datas)
elif args.stream_action:
RuuviTagSensor.get_datas(lambda x: log.info('%s - %s', x[0], x[1]),
bt_device=args.bt_device)
else:
parser.print_usage()
from ruuvitag_sensor.ruuvitag import RuuviTag
import time
import argparse
parser = argparse.ArgumentParser(description='Check for infinite loop.')
parser.add_argument("is_inifinte", nargs='?', default="")
input = parser.parse_args()
mac_addr = 'DE:E5:EA:C5:9C:3E'
count = 0
sensor = RuuviTag(mac_addr)
while count < 2:
if input.is_inifinte == "":
count = count + 1
state = sensor.update()
myoutput = sensor.state
myoutput["MAC"] = mac_addr
myoutput["count"] = count
myoutput["timestamp"] = time.time()
myoutput["ctime"] = time.ctime()
f = open("broadcast.log", "a")
f.write(str(myoutput))
f.write("\n")
f.close()
print(str(myoutput))
time.sleep(60)
from ruuvitag_sensor.ruuvitag import RuuviTag
import threading
from time import gmtime, strftime
#D31FACAA0C9E
sensor = RuuviTag('D1:98:7E:8C:B4:5B')
temp = []
pres = []
acc = []
time = []
##def requestRuuvi():
## threading.Timer(3,requestRuuvi).start()
for i in range(0, 10):
# update state from the device
state = sensor.update()
# get latest state (does not get it from the device)
state = sensor.state
time.append(strftime("%Y-%m-%d %H:%M:%S", gmtime()))
temp.append(state['temperature'])
pres.append(state['pressure'])
acc.append(state['acceleration'])
print(strftime("%Y-%m-%d %H:%M:%S", gmtime()))
print(state['temperature'])
print(state['pressure'])
print(state['acceleration'])
i = i + 1
results = {}
date_time = now_date_time()
weather_url = 'https://api.openweathermap.org/data/2.5/weather?zip={},us&appid={}'.format(
cfg.zip_code, cfg.weather_api_key)
r = requests.get(weather_url)
try:
outside_temp = convCel(r.json()['main']['temp'])
outside_hum = r.json()['main']['humidity']
except:
print(r.json())
results.update({'outside': {'temp': outside_temp, 'humidity': outside_hum}})
for name, mac in sensors.items():
sensor = RuuviTag(mac)
state = sensor.update()
temp = convCel(sensor.state['temperature'])
humidity = sensor.state['humidity']
#print(sensor.state)
results.update({name: {'temp': temp, 'humidity': humidity}})
temp_diff = results['ac_return']['temp'] - results['ac_vent']['temp']
print('Date Read: ', date_time)
for sensor, data in results.items():
temp = data['temp']
hum = data['humidity']
print(sensor, ' Temp:', temp, 'Humidity:', humidity)
url = "https://api.thingspeak.com/update?api_key=%s" % writeAPIkey
messageBuffer = []
fields = ''
_temperature = 19.0
lastConnectionTime = time.time() # Track the last connection time
lastUpdateTime = time.time() # Track the last update time
postingInterval = 60 # Post data once every 1 minutes
updateInterval = 15 # Update once every 15 seconds
# Change here your own device's mac-address ruuvitag
mac = 'F4:9D:33:83:30:29'
print('Starting')
sensor = RuuviTag(mac)
def httpRequest():
'''Function to send the POST request to
ThingSpeak channel for bulk update.'''
# global messageBuffer
global url
global fields
global _temperature
# data = json.dumps({'write_api_key':writeAPIkey,'updates':messageBuffer}) # Format the json data buffer
url_req = url + fields
# print(url_req)
req = urllib.request.Request(url=url_req)
def __init__(self, mac_addr='E8:C7:D7:F2:4B:47', bt_device=''):
self._sensor = RuuviTag(mac_addr, bt_device)
self._data_count = 0
class MyRuuvi():
def __init__(self, mac_addr='E8:C7:D7:F2:4B:47', bt_device=''):
self._sensor = RuuviTag(mac_addr, bt_device)
self._data_count = 0
### Properties ###
@property
def mac(self):
return self._sensor.mac
@property
def state(self):
return self._sensor.state
@property
def temp(self):
return self.state['temperature']
@property
def humid(self):
return self.state['humidity']
@property
def press(self):
return self.state['pressure']
@property
def acc(self):
return self.state['acceleration'] / 1000
@property
def acc_x(self):
return self.state['acceleration_x'] / 1000
@property
def acc_y(self):
return self.state['acceleration_y'] / 1000
@property
def acc_z(self):
return self.state['acceleration_z'] / 1000
@property
def bat(self):
return self.state['battery']
@property
def dataformat(self):
return self.state['data_format']
@property
def elev_x(self):
return math.acos(self.acc_x / self.acc) * 180 / math.pi
@property
def elev_y(self):
return math.acos(self.acc_y / self.acc) * 180 / math.pi
@property
def elev_z(self):
return math.acos(self.acc_z / self.acc) * 180 / math.pi
@property
def rssi(self):
return self.state['rssi']
@property
def data_count(self):
return self._data_count
### Methods ###
def update(self):
self._sensor.update()
self._data_count += 1
def print_to_shell(self):
''' Printing collected data from saved state to shell '''
os.system('clear')
print('\n\r')
print(str(datetime.now()))
print('Sensor:\t{}'.format(self.mac))
print('-'*30)
print('Temperature:\t{:.2f}\t°C'.format(self.temp))
print('Humidity:\t{:.2f}\t%'.format(self.humid))
print('Pressure:\t{:.2f}\thPa'.format(self.press))
print('-'*30)
print('Acceleration:\t{:.3f}\tG'.format(self.acc))
print('X:\t\t{:.3f}\tG'.format(self.acc_x))
print('Y:\t\t{:.3f}\tG'.format(self.acc_y))
print('Z:\t\t{:.3f}\tG'.format(self.acc_z))
print('-'*30)
print('Elevation X:\t{:.0f}\t°'.format(self.elev_x))
print('Elevation Y:\t{:.0f}\t°'.format(self.elev_y))
print('Elevation Z:\t{:.0f}\t°'.format(self.elev_z))
print('-' * 30)
print('RSSI:\t\t{}\tdBm'.format(self.rssi))
print('Battery:\t{:.0f}\tmV'.format(self.bat))
print('Data Count:\t{}'.format(self.data_count))
from ruuvitag_sensor.ruuvi import RuuviTagSensor
from ruuvitag_sensor.ruuvitag import RuuviTag
with open('./config.json') as json_data_file:
data = json.load(json_data_file)
serverUrl = data['variables']['server-url']
bufferFile = data['variables']['buffer-file']
tableName = data['variables']['table-name']
sensorMac = data['variables']['sensor-mac']
sensorUuid = data['variables']['uuid']
ruuvitag_sensor.log.enable_console()
# Beacon mac address
sensor = RuuviTag(sensorMac)
# Unique identifier generated from mac address
uuid = sensorUuid
# update state from the device
state = sensor.update()
# get latest state (does not get it from the device)
state = sensor.state
# double encode json
double_encode = json.dumps(state)
# generate json
jsonData = {
def main_page():
if request.method == "POST":
selected_report = request.form['selected_report']
days_data = request.form['days_data']
else:
selected_report = 'temp_over_time'
days_data = '1'
record_count = DBQuery("SELECT COUNT(*) FROM TEMP_HISTORY WHERE DATE_READ > datetime('now','-{} day')".format(days_data),True)
if record_count==0:
days_data='30'
if days_data=='1':
time_name = '24 Hours'
elif days_data=='3':
time_name = '72 Hours'
elif days_data=='7':
time_name = '7 Days'
else:
time_name = days_data+' Days'
weather_url = 'https://api.openweathermap.org/data/2.5/weather?zip={},us&appid={}'.format(cfg.zip_code,cfg.weather_api_key)
r = requests.get(weather_url)
outside_temp = convCel(r.json()['main']['temp'])
outside_hum = r.json()['main']['humidity']
results = {}
for name, mac in cfg.sensors.items():
sensor = RuuviTag(mac)
state = sensor.update()
temp = convCel(sensor.state['temperature'])
humidity = sensor.state['humidity']
results.update({name:{'temp':temp,'humidity':humidity}})
current_temp_diff = round(results['ac_return']['temp'] - results['ac_vent']['temp'],2)
ac_is_running = True if current_temp_diff>=10 else False
print(ac_is_running)
#SETTING COLOR BASED ON VALUE
if current_temp_diff>=13 and current_temp_diff<16:
current_temp_html = '<span style="color:orange;">{}</span>'.format(current_temp_diff)
elif current_temp_diff>=16:
current_temp_html = '<span style="color:green;">{}</span>'.format(current_temp_diff)
else:
current_temp_html = '<span style="color:red;">{}</span>'.format(current_temp_diff)
db_sensors = [x[0] for x in DBQuery("SELECT DISTINCT SENSOR_NAME FROM TEMP_HISTORY WHERE DATE_READ > datetime('now','-{} day')".format(days_data))]
min_max_temps = {}
for s in db_sensors:
max_hum = DBQuery("SELECT MAX(HUMIDITY) FROM TEMP_HISTORY WHERE SENSOR_NAME='{}' AND DATE_READ > datetime('now','-{} day')".format(s,days_data),True)
min_hum = DBQuery("SELECT MIN(HUMIDITY) FROM TEMP_HISTORY WHERE SENSOR_NAME='{}' AND DATE_READ > datetime('now','-{} day')".format(s,days_data),True)
avg_hum = round(DBQuery("SELECT AVG(HUMIDITY) FROM TEMP_HISTORY WHERE SENSOR_NAME='{}' AND DATE_READ > datetime('now','-{} day')".format(s,days_data),True),2)
max_temp = DBQuery("SELECT MAX(TEMP) FROM TEMP_HISTORY WHERE SENSOR_NAME='{}' AND DATE_READ > datetime('now','-{} day')".format(s,days_data),True)
min_temp = DBQuery("SELECT MIN(TEMP) FROM TEMP_HISTORY WHERE SENSOR_NAME='{}' AND DATE_READ > datetime('now','-{} day')".format(s,days_data),True)
avg_temp = round(DBQuery("SELECT AVG(TEMP) FROM TEMP_HISTORY WHERE SENSOR_NAME='{}' AND DATE_READ > datetime('now','-{} day')".format(s,days_data),True),2)
min_max_temps.update({s:{
'max_temp':max_temp,
'min_temp':min_temp,
'avg_temp':avg_temp,
'max_humidity':max_hum,
'min_humidity':min_hum,
'avg_humidity':avg_hum
}
})
m_m = ['MAX','MIN','AVG']
min_max_diff = {}
for m in m_m:
q_min_max_diff = """
SELECT COALESCE({}(t1.TEMP - (
SELECT t2.TEMP
FROM TEMP_HISTORY AS t2
WHERE t1.DATE_READ=t2.DATE_READ
AND t2.SENSOR_NAME='ac_vent'
)),0)
FROM TEMP_HISTORY AS t1
WHERE t1.SENSOR_NAME='ac_return'
AND DATE_READ > datetime('now','-{} day')
""".format(m,days_data)
temp = round(DBQuery(q_min_max_diff,True),2)
min_max_diff.update({m:temp})
#DETERMINING LAST TOTAL RUNTIME
ac_return_ids= [x[0] for x in DBQuery("SELECT ID FROM TEMP_HISTORY WHERE SENSOR_NAME='ac_return' AND DATE_READ > datetime('now','-{} day') ORDER BY DATE_READ DESC".format(days_data))]
count = 1
last_date = ''
continuous_ids = []
temp_list = []
for i in ac_return_ids:
if count==1:
last_date = DBQuery('SELECT DATE_READ FROM TEMP_HISTORY WHERE ID = {}'.format(i),True)
continuous_ids.append(i)
count+=1
else:
cur_date = DBQuery('SELECT DATE_READ FROM TEMP_HISTORY WHERE ID = {}'.format(i),True)
delta = __datetime(last_date) - __datetime(cur_date)
delta = delta.total_seconds()
print(last_date,cur_date)
temp_list.append(delta-300)
last_date = cur_date
continuous_ids.append(i)
if delta>=310:
break
print(temp_list)
run_start_date = DBQuery("SELECT COALESCE(MAX(DATE_READ),'1970-01-01 13:00:00') FROM TEMP_HISTORY WHERE ID IN ({})".format(','.join([str(x) for x in continuous_ids])),True)
run_end_date = DBQuery("SELECT COALESCE(MIN(DATE_READ),'1970-01-01 12:00:00') FROM TEMP_HISTORY WHERE ID IN ({})".format(','.join([str(x) for x in continuous_ids])),True)
max_ac_return = DBQuery("SELECT COALESCE(MAX(TEMP),0) FROM TEMP_HISTORY WHERE SENSOR_NAME='ac_return' AND DATE_READ='{}'".format(run_end_date),True)
min_ac_return = DBQuery("SELECT COALESCE(MIN(TEMP),0) FROM TEMP_HISTORY WHERE SENSOR_NAME='ac_return' AND DATE_READ='{}'".format(run_start_date),True)
run_delta = __datetime(run_start_date) - __datetime(run_end_date)
run_delta = run_delta.total_seconds()
ac_runtime = sec2humanTime(run_delta)
total_degrees_cooled = max_ac_return - min_ac_return
degrees_over_time = coolAgainstTime(total_degrees_cooled,run_delta)
#RENDER SElECTED GRAPH REPORT
if selected_report=='temp_over_time':
chart = pygal.Line(style=custom_style,x_label_rotation=20)
chart.title = 'Tempature Over {}'.format(time_name)
labels = [x[0] for x in DBQuery("SELECT DISTINCT strftime('%m/%d %Hhrs %Mmins',DATE_READ) FROM TEMP_HISTORY WHERE SENSOR_NAME='attic' AND DATE_READ > datetime('now','-{} day')".format(days_data))]
chart.x_labels = labels
for s in db_sensors:
sensor_name = s
sensor_temps = [x[0] for x in DBQuery("SELECT TEMP FROM TEMP_HISTORY WHERE SENSOR_NAME='{}' AND DATE_READ > datetime('now','-{} day')".format(sensor_name,days_data))]
chart.add(sensor_name,sensor_temps)
elif selected_report=='diff_over_time':
chart = pygal.Line(fill=True, interpolate='cubic', style=custom_style)
chart.title = 'Tempature Differential Over {}'.format(time_name)
labels = [x[0] for x in DBQuery("SELECT DISTINCT strftime('%m/%d %Hhrs',DATE_READ) FROM TEMP_HISTORY WHERE SENSOR_NAME='attic' AND DATE_READ > datetime('now','-{} day')".format(days_data))]
chart.x_labels = labels
data_query = """
SELECT t1.TEMP - (
SELECT t2.TEMP
FROM TEMP_HISTORY AS t2
WHERE t1.DATE_READ=t2.DATE_READ
AND t2.SENSOR_NAME='ac_vent'
)
FROM TEMP_HISTORY AS t1
WHERE t1.SENSOR_NAME='ac_return'
AND DATE_READ > datetime('now','-{} day')
""".format(days_data)
sensor_temps = [x[0] for x in DBQuery(data_query)]
chart.add('Temp Diff',sensor_temps)
graph_data = chart.render_data_uri()
post_url = url_for('main_page')
last_update = DBQuery("SELECT DATE_READ FROM TEMP_HISTORY ORDER BY DATE_READ DESC LIMIT 1",True)
last_update_delta = __datetime(now_date_time()) - __datetime(last_update)
last_update = sec2humanTime(last_update_delta.total_seconds())
return render_template('pygal_reports.html',graph_data=graph_data,outside_temp=outside_temp,
outside_hum=outside_hum,results=results,min_max_temps=min_max_temps,
current_temp_html=current_temp_html,post_url=post_url,
selected_report=selected_report,min_max_diff=min_max_diff,
days_data=days_data,ac_runtime=ac_runtime,degrees_over_time=degrees_over_time,
ac_is_running=ac_is_running,last_update=last_update)
#send
POLES = ['192.168.10.1', '192.168.20.1', '192.168.30.1']
POLESUB = '192.168.'
UDP_IP = '192.168.1.50' ##service IP
UDP_PORT = 9011
MESSAGE = "Fall"
sock = socket.socket(
socket.AF_INET, # Internet
socket.SOCK_DGRAM) # UDP
sock.bind(('0.0.0.0', UDP_PORT))
sensor = RuuviTag('CF:FC:1D:65:2E:98')
networkNow = 0
startTime = time.time()
fall = 0
while True:
state = sensor.update()
state = sensor.state
print(state['acceleration_x'], state['acceleration_y'],
state['acceleration_z'])
if int(state['acceleration_z']) < 500:
print('--------', state['acceleration_x'], state['acceleration_y'],
state['acceleration_z'])
sock.sendto(
bytes((POLESUB + socket.getfqdn().split('.')[1] +
def device_for(self, mac):
from ruuvitag_sensor.ruuvitag import RuuviTag
return RuuviTag(mac)
nargs=1,
metavar='ID',
type=str,
help=
'Bluetooth adapter to use (/dev/hci[x], where x is the adapter number)',
required=True)
return parser.parse_args()
if __name__ == "__main__":
parse = argparse.ArgumentParser(
description="Receive latest measurement from RuuviTag")
args = parseargs(parse)
try:
bt_device = 'hci{}'.format(args.bt_adapter[0])
sensor = RuuviTag(args.mac_address[0], bt_device=bt_device)
state = sensor.update()
if state:
result = "{temp},{hum},{press},{bat},{accel},{accel_x},{accel_y},{accel_z}".format(
temp=state['temperature'],
hum=state['humidity'],
press=state['pressure'],
bat=state['battery'],
accel=state['acceleration'],
accel_x=state['acceleration_x'],
accel_y=state['acceleration_y'],
accel_z=state['acceleration_z'])
print(result, end='')
except Exception:
pass
datas = RuuviTagSensor.get_data_for_sensors(list(datas.keys())[0],
search_duratio_sec=15)
print(datas)
if not datas:
raise Exception('FAILED')
else:
print('OK')
#
# RuuviTag.update
#
print_header('RuuviTag.update')
tag = RuuviTag(list(datas.keys())[0])
tag.update()
print(tag.state)
if not tag.state:
raise Exception('FAILED')
else:
print('OK')
#
# RuuviTagSensor.get_datas
#
print_header('RuuviTagSensor.get_datas')
flag = RunFlag()
help='Find broadcasting RuuviTags')
parser.add_argument('-l',
'--latest',
action='store_true',
dest='latest_action',
help='Get latest data for found RuuviTags')
parser.add_argument('-s',
'--stream',
action='store_true',
dest='stream_action',
help='Stream broadcasts from all RuuviTags')
parser.add_argument('--version',
action='version',
version='%(prog)s {}'.format(
ruuvitag_sensor.__version__))
args = parser.parse_args()
if args.mac_address:
sensor = RuuviTag(args.mac_address)
state = sensor.update()
log.info(state)
elif args.find_action:
RuuviTagSensor.find_ruuvitags()
elif args.latest_action:
datas = RuuviTagSensor.get_data_for_sensors()
log.info(datas)
elif args.stream_action:
RuuviTagSensor.get_datas(lambda x: log.info('%s - %s' % (x[0], x[1])))
else:
parser.print_usage()
from ruuvitag_sensor.ruuvitag import RuuviTag
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--tag")
args = parser.parse_args()
# print args.tag
sensor = RuuviTag(args.tag)
state = sensor.update()
# get latest state (does not get it from the device)
state = sensor.state
print(state)
RuuviTag's update-method will always create new bluetooth scanning
process and eventually process creation may fail.
"""
import time
import os
from datetime import datetime
from ruuvitag_sensor.ruuvitag import RuuviTag
# Change here your own device's mac-address
mac = 'F4:A5:74:89:16:57'
print('Starting')
sensor = RuuviTag(mac)
while True:
data = sensor.update()
line_sen = str.format('Sensor - {0}', mac)
line_tem = str.format('Temperature: {0} C', data['temperature'])
line_hum = str.format('Humidity: {0}', data['humidity'])
line_pre = str.format('Pressure: {0}', data['pressure'])
# Clear screen and print sensor data
os.system('clear')
print('Press Ctrl+C to quit.\n\r\n\r')
print(str(datetime.now()))
print(line_sen)
print(line_tem)
s3 = boto3.resource('s3',
aws_access_key_id=ACCESS_ID,
aws_secret_access_key=ACCESS_KEY)
obj = s3.Object(bucket, taglist)
body = obj.get()['Body'].read()
tags = json.loads(body)
print(tags)
measurements = []
for tag in tags:
sensor = RuuviTag(tags[tag])
state = sensor.update()
#print('state: ' + str(state))
datas = (tag, state['temperature'], round(state['pressure']),
round(state['humidity']))
measurements.append(datas)
sql = '''INSERT INTO observations (tagname, date, time, temperature, pressure, relativehumidity, timestamp)
VALUES(%s, CURRENT_DATE(), CURRENT_TIME(), %s, %s, %s, UNIX_TIMESTAMP())'''
db = pymysql.connect(host="127.0.0.1",
user=user,
passwd=passwd,
db=db,
port=port)
