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)
