def get_data(ruuvitags='', timeout=5):
# Tällä funktiolla voi hakea useammasta ruuvitagista datan samalla kertaa
info('Listening data from RuuviTags for {:}s'.format(timeout))
data = RuuviTagSensor.get_data_for_sensors(ruuvitags, timeout)
debug('Received data:')
debug(data)
return data
def main(args):
while True:
if args.simulate:
time.sleep(timeout_in_sec)
datas = EXAMPLE_DATA
else:
try:
datas = RuuviTagSensor.get_data_for_sensors(macs, timeout_in_sec)
except Exception as err:
print('ERROR at {}'.format(datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.%fZ")))
print('{}'.format(err))
if args.protocol == 'http':
http_post2influxdb(datas, simulate=args.simulate)
if args.verbose > 1:
print('POSTing data "{}"'.format(json.dumps(datas)))
elif args.protocol == 'mqtt':
json_data = create_influxdb_packet(datas)
pl = json.dumps(json_data)
if args.verbose > 1:
print('Publish MQTT message {} on topic {}'.format(pl, args.topic))
result, mid = mclient.publish(args.topic, payload=pl, qos=0, retain=False)
if args.quiet is False and result != 0:
print('MQTT publish error! {}'.format(result))
else:
if args.quiet is False:
print("Not sending because protocol is not defined")
if args.verbose > 0:
print(json.dumps(datas, indent=1))
continue
def collect_and_store(self):
if self.mock:
sensors = self.mock.mac_to_name
t = next(self._mock_time)
datas = next(self._mock_datas)
else:
sensors = self.get_sensors()
t = datetime.now()
datas = RuuviTagSensor.get_data_for_sensors(
sensors, int(self.timeout))
t_str = t.strftime('%Y-%m-%d %H:%M:%S')
for mac in sensors:
record = {
'sensor_MAC': mac,
'sensor_name': sensors[mac],
'timestamp': t_str,
'year': t.year,
'month': t.month,
'day': t.day
}
if mac in datas:
record.update(datas[mac])
if self.log_data:
print(t, record)
self.database_table.insert(record)
def run_get_data_background(macs, queue):
"""
Background process from RuuviTag Sensors
"""
while True:
datas = RuuviTagSensor.get_data_for_sensors(macs, timeout_in_sec)
queue.put(datas)
def test_get_data_for_sensors(self):
macs = ['CC:2C:6A:1E:59:3D', 'DD:2C:6A:1E:59:3D']
data = RuuviTagSensor.get_data_for_sensors(macs, 4)
self.assertEqual(2, len(data))
self.assertTrue('CC:2C:6A:1E:59:3D' in data)
self.assertTrue('DD:2C:6A:1E:59:3D' in data)
self.assertTrue(data['CC:2C:6A:1E:59:3D']['temperature'] == 24.0)
def run(self):
"""Continuously scan for BLE advertisements."""
macs = set(map(lambda x : x.mac, self.devices))
while not self.keep_going.wait(10):
items = RuuviTagSensor.get_data_for_sensors(macs)
self.process_packet(items)
def get_tag_data(temp_macs):
macs = []
for mac in temp_macs:
# convert 1234567890 -> 12:34:45:78:90
macs.append(':'.join(format(s, '02x')
for s in bytes.fromhex(mac)).upper())
timeout_in_sec = 20
datas = RuuviTagSensor.get_data_for_sensors(macs, timeout_in_sec)
logger.debug('collected data: "{}"'.format(str(datas)))
return datas[macs[0]]
def main():
ruuvitag_sensor.log.enable_console()
sensor_data = RuuviTagSensor.get_data_for_sensors(MAC, TIMEOUT)
json_sensor_data = json.dumps(sensor_data).encode()
print(json_sensor_data)
send_sensor_data_iot_hub(json_sensor_data)
def _get_temperature(ruuvitag_mac_address):
logging.info(f'Using Ruuvi mac: {ruuvitag_mac_address}')
logging.info('Attempting ruuvi update...')
ruuvi_data = RuuviTagSensor.get_data_for_sensors([ruuvitag_mac_address], 4)
logging.info(f'Ruuvi data: {ruuvi_data}')
if not ruuvitag_mac_address in ruuvi_data:
raise RuntimeError('No result for ruuvi mac')
temp_c = ruuvi_data[ruuvitag_mac_address]['temperature']
temp_f = temp_c * 180. / 100. + 32.
logging.info(f'Temperature in fahrenheit: {temp_f}')
return temp_f
def fetch_data_and_send(listening_time=10):
print('Fetching data...')
data = RuuviTagSensor.get_data_for_sensors(
search_duratio_sec=listening_time)
print('Data fetch OK!')
print('Found tags:')
if len(data) > 0:
for i, value in enumerate(data):
print(str(i + 1) + ' : ' + value)
write_to_influxdb(list(data.items())[i])
print('Data send succesfully!')
def read_tags():
raw_tag_datas = RuuviTagSensor.get_data_for_sensors(TAGS.keys(), 5)
tag_datas = []
for mac, raw_tag_data in raw_tag_datas.items():
tag = TAGS.get(mac)
if not tag:
continue
tag_datas.append({
COL_TAG_MAC: mac,
COL_TEMP: raw_tag_data.get("temperature"),
COL_HUMIDITY: raw_tag_data.get("humidity")
})
return tag_datas
def run_get_data_background(macs, queue):
"""
Background process from RuuviTag Sensors
"""
while True:
try:
datas = RuuviTagSensor.get_data_for_sensors(macs, timeout_in_sec)
queue.put(datas)
except KeyboardInterrupt:
# When Ctrl+C is pressed
# execution of the while loop is stopped
print('Exit')
break
def collect_readings():
print("Collecting readings...")
try:
datas = RuuviTagSensor.get_data_for_sensors(macs, get_data_timeout_sec)
measurements = []
for mac, data in datas.items():
data["mac"] = mac
data["name"] = get_name(mac)
measurements.append(data)
body = {"measurements": measurements}
requests.post(config["collector_url"], json=body)
print(f"Sent {len(measurements)} measurements to collector")
except Exception as e:
print("Failed to collect and send readings")
print(e)
def getData(self):
os.system('clear')
macs = []
conn = sqlite3.connect(dataBaseDjangoDir)
cursor = conn.cursor()
cursor.execute("""select * from tags_tag""")
conn.commit()
query = (cursor.fetchall())
for tag in query:
macs.append(tag[1])
datas = RuuviTagSensor.get_data_for_sensors(macs, timeout_in_sec)
# Dictionary will have lates data for each sensor
for mac in macs:
try:
tag = datas[mac]
date = datetime.datetime.now()
TUPLA = (mac,
tag['battery'],
tag['temperature'],
tag['humidity'],
int(date.year),
int(date.month),
int(date.day),
int(date.hour),
int(date.minute),
int(date.second),
)
vetor = [TUPLA, ]
print("VETOR : ", vetor)
try:
conn = sqlite3.connect(dataBaseSensiDir)
cursor = conn.cursor()
cursor.executemany("""
INSERT INTO reg (MAC, BATERIA, TEMPERATURA,UMIDADE,ANO,MES,DIA,HORA,MINUTO,SEGUNDO)
VALUES (?,?,?,?,?,?,?,?,?,?)
""", vetor)
conn.commit()
conn.close()
except KeyError:
print ('erro do banco')
except KeyError:
print ('tag n encontrada: ' + mac)
def get():
macs = [config.TAG_ASUNTO_MAC, config.TAG_YLEINEN_MAC]
timeout_in_sec = 4
datas = RuuviTagSensor.get_data_for_sensors(macs, timeout_in_sec)
asunto = datas[config.TAG_ASUNTO_MAC]
yleinen = datas[config.TAG_YLEINEN_MAC]
timestamp = str(datetime.datetime.now())
asunto_data = "Asunto: " + str(asunto["temperature"]) + " C " + str(
asunto["humidity"]) + " % " + str(asunto["pressure"]) + " hPa "
yleinen_data = "Yleinen: " + str(yleinen["temperature"]) + " C " + str(
yleinen["humidity"]) + " % " + str(yleinen["pressure"]) + " hPa "
return_data = timestamp + "\n" + asunto_data + "\n" + yleinen_data
return return_data
tags = config["tags"]
if "logging" in config:
log_config = config["logging"]
logging.config.dictConfig(log_config)
logger.info('Starting RuuviTag gateway.')
stamp = now()
client = mqtt.Client()
client.username_pw_set(username=user, password=password)
client.connect(mqtt_broker, mqtt_broker_port, 600)
logger.info('Connected to MQTT broker ')
while True:
try:
if now() - stamp > update_frequency_seconds:
tag_data = RuuviTagSensor.get_data_for_sensors(
tags.values(), timeout_in_sec)
timestamp = time_milliseconds()
if tag_data:
for key, value in tag_data.items():
pub_topic = topic + str(key)
value_str = 'T: ' + str(
value['temperature']) + ' H: ' + str(
value['humidity']) + ' P: ' + str(
value['pressure']) + ' B: ' + str(
value['battery'] / 1000)
logger.info("Topic {topic} : {value}".format(
topic=pub_topic, value=value_str))
client.publish(pub_topic, json.dumps(value))
time.sleep(update_frequency_seconds)
except KeyboardInterrupt:
print('Exit')
def update(self):
self.datas = RuuviTagSensor.get_data_for_sensors(
self.macs, self.timeout)
from datetime import datetime
from ruuvitag_sensor.ruuvi import RuuviTagSensor
from google.cloud import firestore
SCAN_TIMEOUT = 4
db = firestore.Client()
measurements_ref = db.collection(u'measurements')
timestamp = datetime.now()
def measurement_to_firestore(mac, payload):
result = payload.copy()
result["mac"] = mac
result["timestamp"] = timestamp
return result
datas = RuuviTagSensor.get_data_for_sensors(None, SCAN_TIMEOUT)
for mac, payload in datas.items():
value = measurement_to_firestore(mac, payload)
measurements_ref.add(value)
print('[{0}] Measurement added for {1}'.format(timestamp.strftime('%Y-%m-%d %H:%M:%S'), mac))
"""
Get data from sensors and post it to specified url in json-format
Requires:
Requests - pip install requests
"""
from urllib.parse import quote
import requests
from ruuvitag_sensor.ruuvi import RuuviTagSensor
macs = ['F4:A5:74:89:16:57', 'CC:2C:6A:1E:59:3D', 'BB:2C:6A:1E:59:3D']
# This should be enough that we find at least one result for each
timeout_in_sec = 4
url = 'http://localhost:8000/data/'
datas = RuuviTagSensor.get_data_for_sensors(macs, timeout_in_sec)
# Use Requests to POST datas in json-format
# Encode mac as it contains semicolon, which is reserved character
for key, value in datas.items():
# url e.g.: http://localhost:8000/data/F4%3AA5%3A74%3A89%3A16%3A57
# json e.g.: {"temperature": 24.0, "humidity": 38.0, "pressure": 1018.0}
requests.post(url + quote(key), json=value)
decoder = Df3Decoder()
data = decoder.decode_data('03291A1ECE1EFC18F94202CA0B5300000000BB')
print(data)
if not data['temperature']:
raise Exception('FAILED')
else:
print('OK')
#
# RuuviTagSensor.get_data_for_sensors
#
print_header('RuuviTagSensor.get_data_for_sensors')
datas = RuuviTagSensor.get_data_for_sensors(search_duratio_sec=15)
print(datas)
if not datas:
raise Exception('FAILED')
else:
print('OK')
#
# RuuviTagSensor.get_data_for_sensors with macs
#
print_header('RuuviTagSensor.get_data_for_sensors with macs')
datas = RuuviTagSensor.get_data_for_sensors(list(datas.keys())[0],
search_duratio_sec=15)
print(datas)
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()
#!/usr/bin/python3 import json import sys import errno import datetime from time import sleep from ruuvitag_sensor.ruuvi import RuuviTagSensor mac = sys.argv[1] macs = [mac] sleepTime = 2.5 datas = RuuviTagSensor.get_data_for_sensors(macs, sleepTime) #print(str(datas)) # convert json to string dump = json.dumps(datas) data = json.loads(dump) # print(str(data[mac]))
client = InfluxDBClient(host="localhost", port=8086, database="tag_data")
count = 0
print("sending data")
'''
sensor = RuuviTag(mac)
while True:
data = sensor.update()
'''
while True:
try:
print("reading Data")
#datas = RuuviTag.update()
datas = RuuviTagSensor.get_data_for_sensors(macs='EE:A1:C8:AF:34:5D')
print(datas)
print("reading Done")
json_body = [
convert_to_influx(mac, payload) for mac, payload in datas.items()
]
client.write_points(json_body)
print("sending successful")
print(count)
count = count + 1
except:
print("sending failed")
'''
# Wait for 2 seconds and start again
try:
time.sleep(2)
def run(mac, timeout=3):
# This can handle more than one MAC address
return RuuviTagSensor.get_data_for_sensors([mac], timeout)
datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%SZ'),
'SensorId':
mac,
'Location':
ruuvi_name_list[mac]
})
def AddDataPoints(data_received):
global data_points
for mac in ruuvi_mac_list:
if mac not in data_points:
data_points[mac] = []
if mac in data_received:
data_points[mac].append(data_received[mac])
for ruuvi_tag in ruuvi_tag_list:
mac = ruuvi_tag.split(";")[1]
name = ruuvi_tag.split(";")[0]
ruuvi_mac_list.append(mac)
ruuvi_name_list[mac] = name
with gih.GracefulInterruptHandler() as hander:
while True:
for x in range(30): # 5minutes
data = RuuviTagSensor.get_data_for_sensors(ruuvi_mac_list, 4)
AddDataPoints(data)
time.sleep(10)
SendAggregateDataToIngester()
def start_collection(self):
print("starting to collect data")
collected_data = RuuviTagSensor.get_data_for_sensors(
self.macs, self.timeout_in_sec)
self.handle_data(collected_data)
'acceleration_z' in payload) else None
fields["batteryVoltage"] = payload["battery"] / 1000.0 if hasattr(
payload, 'battery') else None
fields["txPower"] = payload["tx_power"] if ('tx_power'
in payload) else None
fields["movementCounter"] = payload["movement_counter"] if (
'movement_counter' in payload) else None
fields["measurementSequenceNumber"] = payload[
"measurement_sequence_number"] if ('measurement_sequence_number'
in payload) else None
fields["tagID"] = payload["tagID"] if ('tagID' in payload) else None
fields["rssi"] = payload["rssi"] if ('rssi' in payload) else None
return {
"measurement": "ruuvi_measurements",
"tags": {
"mac": mac,
"dataFormat": dataFormat
},
"fields": fields
}
client = InfluxDBClient(host="localhost", port=8086, database="ruuvi")
while True:
datas = RuuviTagSensor.get_data_for_sensors()
json_body = [
convert_to_influx(mac, payload) for mac, payload in datas.items()
]
client.write_points(json_body)
