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)