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)