def run_get_datas_background(queue):
def handle_data(data):
mac = get_topic(data[0])
value = data[1]
queue.put((mac, value))
RuuviTagSensor.get_datas(handle_data)
def main():
def handle_data(found_data):
print(
f'Found ruuvitag with MAC addres: {found_data[0]}\n{found_data[1]}'
)
RuuviTagSensor.get_datas(handle_data)
def getData(self):
'''
Get received data, or receive the data first if not already done
'''
if not self.dataReceivedFromAllTheTags:
RuuviTagSensor.get_datas(self._handleData, self.macs, self.run_flag)
pass
return self.macsWithData
def run_get_data_background(macs, queue):
"""
Background process from RuuviTag Sensors
"""
def callback(data):
data[1]['time'] = str(datetime.now())
queue.put(data)
RuuviTagSensor.get_datas(callback, macs)
def test_tag_update_is_valid(self):
tag = RuuviTagSensor('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 flood_data():
def handle_data(data_list):
mac, data = data_list
record = {'MAC': mac, 'timestamp': datetime.now()}
record.update(data)
print(record)
print()
print('Flooding console with Ruuvi tag data...')
RuuviTagSensor.get_datas(handle_data)
def _run_get_data_background(macs, queue, run_flag):
"""
Background process from RuuviTag Sensors
"""
def add_data(data):
data[1]['time'] = str(datetime.now())
queue.put(data)
RuuviTagSensor.get_datas(add_data, macs, run_flag)
def get_measurements():
run_flag_outside.running = True
run_flag_inside.running = True
t2 = threading.Timer(settings.SUPERVISION_PERIOD, cancel_measurements)
ts.start()
RuuviTagSensor.get_datas(handle_outside_data, settings.RUUVI_OUTSIDE,
run_flag_outside)
RuuviTagSensor.get_datas(handle_inside_data, settings.RUUVI_INSIDE,
run_flag_inside)
t1 = threading.Timer(settings.MEASUREMENT_INTERVAL, get_measurements)
t1.start()
def run_get_datas_background(queue):
def handle_new_data(new_data):
current_time = datetime.now()
sensor_mac = new_data[0]
sensor_data = new_data[1]
if sensor_mac not in all_data or all_data[sensor_mac]['data'] != sensor_data:
update_data = {'mac': sensor_mac, 'data': sensor_data, 'timestamp': current_time.isoformat()}
all_data[sensor_mac] = update_data
queue.put(update_data)
RuuviTagSensor.get_datas(handle_new_data)
def main(filename: str):
config = read_config(filename)
logger.setLevel(level=LOG_LEVEL[config.log_level])
logger.debug("Started with the following config:")
logger.debug(str(config))
client = connect_influxdb(config)
def callback(data: List) -> None:
return ruuvi_callback(config, client, data)
RuuviTagSensor.get_datas(callback, macs=config.mac_filter)
def main():
database_file = '/var/lib/ilmaruuvi/db.hdf'
logfile = '/var/log/ilmaruuvi.log'
MAC1 = 'E8:A8:F2:B1:AE:A3'
sensor = RuuviTagSensor(MAC1)
while True:
state = sensor.update()
with open(logfile, 'a') as f:
f.write('{time},{t},{rh},{p}\n'.format(
time=datetime.today().strftime('%Y-%m-%d %H:%M:%S'),
t=state['temperature'],
rh=state['humidity'],
p=state['pressure']))
time.sleep(10 * 60)
def _run_get_data_background(macs, queue, shared_data, bt_device):
"""
Background process function for RuuviTag Sensors
"""
run_flag = RunFlag()
def add_data(data):
if not shared_data['run_flag']:
run_flag.running = False
data[1]['time'] = str(datetime.now())
queue.put(data)
RuuviTagSensor.get_datas(add_data, macs, run_flag, bt_device)
def main():
MAC1 = 'E8:A8:F2:B1:AE:A3'
sensor = RuuviTagSensor(MAC1)
while True:
state = sensor.update()
if state is None:
continue
now = datetime.today()
database_file = '/var/lib/ilmaruuvi/{}.csv'.format(now.strftime('%Y%m%d'))
with open(database_file, 'a') as f:
f.write('{time},{t},{rh},{p}\n'.format(time=now.strftime('%Y-%m-%d %H:%M:%S'),
t=state['temperature'],
rh=state['humidity'],
p=state['pressure']))
time.sleep(880)
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 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 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 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 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 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 start_reporting(**kwargs):
flag = RunFlag()
def handle_sigint(sig, frame):
flag.running = False
sensors = read_data()
handler = RuuviDataHandler(sensors, **kwargs)
signal(SIGINT, handle_sigint)
while flag.running:
try:
RuuviTagSensor.get_datas(handler, None, flag)
except KeyboardInterrupt:
return
except Exception:
pass
def test_tag_correct_properties(self):
org_mac = 'AA:2C:6A:1E:59:3D'
tag = RuuviTagSensor(org_mac)
mac = tag.mac
state = tag.state
self.assertEqual(mac, org_mac)
self.assertEqual(state, {})
def listener(data, tag, interval):
try:
# RunFlag for stopping execution at desired time
run_flag = RunFlag()
def handle_data(values):
# Send data to main process
data[tag["index"]] = values[1]
run_flag.running = False # Stop process
time.sleep(interval) # Wait interval
run_flag.running = True # Continue process
RuuviTagSensor.get_datas(handle_data, tag["address"], run_flag)
except ValueError:
data[tag["index"]] = "RuuviTag address is not correct."
except Exception as e:
data[tag["index"]] = "Error happened while trying to read RuuviTag values."
print(e)
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 discover_sensors():
seen_macs = set()
n_macs_last_seen = [0]
sensor_names = yaml.load(
open('sensors.yml')) if path.exists('sensors.yml') else {}
def handle_data(data_list):
mac, data = data_list
seen_macs.add(mac)
if len(seen_macs) != n_macs_last_seen[0]:
n_macs_last_seen[0] = len(seen_macs)
print()
print('Seeing Ruuvi MACS:')
for mac in sorted(seen_macs):
print('mac <<>> %s' %
sensor_names[mac] if mac in sensor_names else '%s (!)' %
mac)
print('Looking for Ruuvi tags...')
RuuviTagSensor.get_datas(handle_data)
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 _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 find_tags(self):
"""
Find all RuuviTags.
Returns:
dict: MAC and state of found sensors
"""
global BLUEZ_ERROR_DISPLAYED
logger.debug("Try to find tags...")
# This is the amount of time to listen for tags - TODO get from config file
timeout = 10
tags = {}
tags_skip = {}
macs = []
start = current_milli_time()
try:
for data in RuuviTagSensor._get_ruuvitag_datas(macs, timeout):
if current_milli_time() > (start+(timeout*1000)):
break
if (data[0] in tags) or (data[0] in tags_skip):
continue
logger.debug("Found TAG {}, DATA {}".format(data[0],data[1]))
data_format = data[1]['data_format']
if data_format < 4:
tags[data[0]] = data[1]
else:
tags_skip[data[0]] = data[1]
logger.debug("Skipping data_format 4 tag - polling locks up thread")
except:
logger.error("error while finding tags")
if tags is None or len(tags)==0:
if not BLUEZ_ERROR_DISPLAYED:
BLUEZ_ERROR_DISPLAYED = True
logger.warning("No RuuviTags Found. Verify this is running on Raspian and "
"that you have installed BLUEZ: 'sudo apt-get install bluez-hcidump'")
return tags
def ruuviListen():
def handle_data(found_data):
global tags
global counter
mac = found_data[0]
temp = found_data[1]['temperature']
# update the tag with the reading
tags[mac]['temp'] = found_data[1]['temperature']
#counter = counter - 1
#if counter < 0:
#run_flag.running = False
#if (mac == insideTag):
#print("insideTag temp", temp)
#elif (mac == outsideTag):
#print("outsideTag temp", temp)
#else:
#print("error - unknown tag ", mac)
RuuviTagSensor.get_datas(handle_data, None, run_flag)
print("RuuviTagSensor returned")
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 main():
RuuviTagSensor.get_datas(handle_ruuvi)
