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 _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 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 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 _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 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 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 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 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 start_publishing(config_file_path: Path): global config logger.info("Using config file: %s", config_file_path) if not config_file_path: config_file_path = Path(__file__).parent / "ruuvitag_mqtt.json" with open(config_file_path) as config_file: config = json.load(config_file) print(config) username = config.get("broker", {}).get("username") if username: logger.info("Using authentication: %s", username) password = config.get("broker", {}).get("password") mqtt_client.username_pw_set(username=username, password=password) mqtt_client.connect( host=config.get("broker", {}).get("host", "localhost"), port=config.get("broker", {}).get("port", 1883), ) mqtt_client.disconnect() RuuviTagSensor.get_datas(on_ruuvi_event)
def test_get_datas_with_macs(self): datas = [] macs = ['CC:2C:6A:1E:59:3D', 'DD:2C:6A:1E:59:3D'] RuuviTagSensor.get_datas(datas.append, macs) self.assertEqual(2, len(datas))
from ruuvitag_sensor.ruuvi import RuuviTagSensor # List of macs of sensors which data will be collected # If list is empty, data will be collected for all found sensors tag1 = 'C3:60:95:50:C6:0E' def handle_data(found_data): print('MAC ' + found_data[0]) print(found_data[1]) macs = [tag1] RuuviTagSensor.get_datas(handle_data, macs)
value = str(avg_data) + " " + unit datas.append(value.ljust(config.column_width)) dline = ''.join(datas) return dline def title(): ''' Returns the header associated with data_line() Use: print( title() ) ''' titles = [] for i in State.tags: titles.append((State.tags[i].id).ljust(config.column_width)) dtitle = ''.join(titles) return dtitle def avg(lst): ''' returns the average of the list ''' return sum(lst) / len(lst) # The recommended way of listening to current Ruuvitags, using interrupts RuuviTagSensor.get_datas(handle_data)
def handledata(found_data): mac = found_data[0] # mulla on kaks ruuvitagia niin ne tulee sit erikseen tässä # # if found_data[0] == '00:00:00:00:00:00': # mac = 1 # elif found_data[0] == '11:11:11:11:11:11': # mac = 2 data = found_data[1] url = "http://51.83.73.200/iot/sensordata.php" info = {'user': '******', 'pass': '******', 'deviceid': mac, 'temperature': data['temperature'], 'humidity': data['humidity'], 'pressure': data['pressure']} r = requests.post(url=url, data=info) print(info) # lähtevät tiedot print(r.text, r.status_code, r.reason) # serverin vastaus global counter counter = counter - 1 if counter <= 0: run_flag.running = False mac = '22:22:22:22:22:22' #tähän oma ruuvitag mac-osoite #macs = ['11:11:11:11:11:11','00:00:00:00:00:00'] RuuviTagSensor.get_datas(handledata, mac, run_flag) # jos 2 > niin tähän mac:n tilalle macs
def test_get_datas(self): datas = [] RuuviTagSensor.get_datas(lambda x: datas.append(x)) self.assertEqual(5, len(datas))
def worker(): RuuviTagSensor.get_datas(save_scan, macs)
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()
def test_get_datas(self): datas = [] RuuviTagSensor.get_datas(datas.append) self.assertEqual(7, len(datas))
def ruuvi_main(mqtt_queue: multiprocessing.Queue, config: Dict[str, Any]) -> None: """ Main function for the Ruuvi process Read messages from BLE, and push them to the queue """ # Used to track the last measurement we've seen, to avoid # sending duplicate ones. # # Measurement numbers go up, normally, possibly skipping entries. # They may also go down (when a Ruuvi reboots) last_measurement: Dict[str, int] = defaultdict(lambda: 0) def dewpoint(temperature: float, humidity: float) -> float: """ Calculate an approximate dewpoint temperature Tdp, given a temperature T and relative humidity H. This uses the Magnus formula: N = ln(H / 100) + (( b * T ) / ( c + T )) Tdp = ( c * N ) / ( b - N ) The constants b and c come from https://doi.org/10.1175/1520-0450(1981)020%3C1527:NEFCVP%3E2.0.CO;2 and are b = 17.368 c = 238.88 for temperatures >= 0 degrees C and b = 17.966 c = 247.15 for temperatures < 0 degrees C """ if temperature >= 0: b = 17.368 c = 238.88 else: b = 17.966 c = 247.15 N = math.log(humidity / 100) + ((b * temperature) / (c + temperature)) return (c * N) / (b - N) def ruuvi_handle_data(found_data: Tuple[str, Dict[str, Any]]) -> None: """ Callback function for tag data Enrich the data with the current time, and push to queue. If the queue is full, drop the data. """ nonlocal mqtt_queue nonlocal last_measurement mac, data = found_data lmac = mac.lower() LOGGER.debug("Read ruuvi data from mac %s: %s", mac, data) if "measurement_sequence_number" not in data or "mac" not in data: LOGGER.error( "Received measurement without sequence number or mac: %s", data) return cur_seq = data["measurement_sequence_number"] last_seq = last_measurement[data["mac"]] if cur_seq == last_seq: # Duplicate entry LOGGER.debug( "Received duplicate measurement %s from %s, ignoring", cur_seq, data["mac"], ) return last_measurement[data["mac"]] = cur_seq # Sometimes Ruuvitags send humitity values ~100% offset from the # "real" value. Ignore these, leaving a small window for values > # 100%, which might be real if data["humidity"] > 105: LOGGER.error("Received invalid humidity value %.2f%%, ignoring", data["humidity"]) return # Process the data through offset functions if lmac in config["offset_poly"]: processed_data = {} for key, value in data.items(): if key in config["offset_poly"][lmac]: # Ruuvi sends data with two significant digits, # round the scaled data as well processed_data[key] = round( config["offset_poly"][lmac][key](value), 2) processed_data["ruuvi_mqtt_raw_%s" % (key, )] = value else: processed_data[key] = value data = processed_data # Add the dew point temperature, if requested if config["dewpoint"]: data["ruuvi_mqtt_dewpoint"] = round( dewpoint(data["temperature"], data["humidity"]), 2) LOGGER.debug("Processed ruuvi data from mac %s: %s", mac, data) # Find the device name, if any # Use the `mac` field as a fallback data["ruuvi_mqtt_name"] = config["macnames"].get(lmac, data["mac"]) # Add a time stamp. This is an integer, in milliseconds # since epoch data["ruuvi_mqtt_timestamp"] = int(time.time() * 1000) try: mqtt_queue.put(data, block=False) except Exception: # Ignore this pass LOGGER.info("ruuvi process starting") RuuviTagSensor.get_datas(ruuvi_handle_data, [x.upper() for x in config["filter"]])
} temp_gauge = Gauge('ruuvi_temperature_c', 'Temperature in Celsius', ['location']) humidity_gauge = Gauge('ruuvi_humidity_percent', 'Humidity %', ['location']) pressure_gauge = Gauge('ruuvi_pressure_hpa', 'Air pressure hPa', ['location']) battery_gauge = Gauge('ruuvi_battery_v', 'Battery V', ['location']) def handle_data(data): [mac, sensor_data] = data beacon = beacons[mac] beacon['last_update'] = time.time() beacon['sensor_data'] = sensor_data location = beacon['name'] temp_gauge.labels(location).set(sensor_data['temperature']) humidity_gauge.labels(location).set(sensor_data['humidity'] / 100.0) pressure_gauge.labels(location).set(sensor_data['pressure']) battery_gauge.labels(location).set(sensor_data['battery'] / 1000.0) def sigint_handler(signal, frame): print("Collected data:") pprint.pprint(beacons) sys.exit(130) if __name__ == '__main__': signal.signal(signal.SIGINT, sigint_handler) print("Starting HTTP server for Prometheus scraping") start_http_server(8000) print("Reading data from Ruuvi tags") RuuviTagSensor.get_datas(handle_data, beacons.keys())
mac = received_data[0] payload = received_data[1] dataFormat = payload['data_format'] if ('data_format' in payload) else None fields = {} fields['temperature'] = payload['temperature'] if ('temperature' in payload) else None fields['humidity'] = payload['humidity'] if ('humidity' in payload) else None fields['pressure'] = payload['pressure'] if ('pressure' in payload) else None fields['accelerationX'] = payload['acceleration_x'] if ('acceleration_x' in payload) else None fields['accelerationY'] = payload['acceleration_y'] if ('acceleration_y' in payload) else None fields['accelerationZ'] = payload['acceleration_z'] if ('acceleration_z' in payload) else None fields['batteryVoltage'] = payload['battery']/1000.0 if ('battery' in payload) 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 json_body = [ { 'measurement': 'ruuvi_measurements', 'tags': { 'mac': mac, 'dataFormat': dataFormat }, 'fields': fields } ] client.write_points(json_body) RuuviTagSensor.get_datas(write_to_influxdb)
def run(self): RuuviTagSensor.get_datas(self.handle_data)
from ruuvitag_sensor.ruuvi import RuuviTagSensor # Change here your own device's mac-address mac = 'F4:A5:74:89:16:57' print('Starting') def print_data(received_data): received_mac = received_data[0] data = received_data[1] line_sen = str.format('Sensor - {0}', received_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) print(line_hum) print(line_pre) print('\n\r\n\r.......') if __name__ == "__main__": RuuviTagSensor.get_datas(print_data, mac)
time = datetime.now() #aika #data stringinä tiedot = time.strftime( '%d %m %Y, %H:%M' ), 'lämpötila: ', temp, 'kosteus: ', hum, 'paine: ', press, 'akku: ', battery #saadun datan kirjoittaminen tekstitiedostoon with open('ruuvit.txt', 'a') as myfile: myfile.write(str(mac) + '\n') myfile.write(str(tiedot) + '\n') #printtaus konsoliin print('ruuvitag mac: ' + mac) print(tiedot) #get_data:n suorittamisen lopetus global counter counter = counter - 1 if counter < 0: run_flag.running = False macs = ['CB:1B:A6:85:DB:83', 'EA:17:44:5F:8E:80'] # callback (macs-muuttujan ruuvitageille, run_flag laskurille) että saadaan get_datan suoritus # pysäytettyä halutun ajan päästä (tässä tapauksessa kun ollaan saatu 1 kerran molemmilta # ruuvitageilta datat) RuuviTagSensor.get_datas(handle_data, macs, run_flag)
def main(): RuuviTagSensor.get_datas(handle_ruuvi)
def run(self): RuuviTagSensor.get_datas(self.cb, MACS)