def handle_message(influx_client, receiver_mac, mac, rssi, data, raw_msg):
if data is None:
if mac not in ignored_macs:
print("Got null data from %s" % mac, raw_msg)
ignored_macs.add(mac)
return
if len(data) < 2:
print("Got too short message from %s, length: %d" % (mac, len(data)))
return
if data[0:2] != bytes.fromhex("9904"):
if mac not in ignored_macs:
print("Got non-ruuvitag message from %s" % mac)
ignored_macs.add(mac)
return
if len(data) < 3:
print(
"Unexpected message with ruuvitag manufacturer code from: %s, data: %s"
% (mac, data.hex()))
return
format = data[2]
payload = get_decoder(format).decode_data(data[2:].hex())
if payload is not None:
json_body = convert_to_influx(receiver_mac, mac, payload)
if not args.quiet:
print(json_body)
if not args.test:
influx_client.write_points([json_body])
def _get_ruuvitag_datas(macs=[],
search_duratio_sec=None,
run_flag=RunFlag(),
bt_device=''):
"""
Get data from BluetoothCommunication and handle data encoding.
Args:
macs (list): MAC addresses. Default empty list
search_duratio_sec (int): Search duration in seconds. Default None
run_flag (object): RunFlag object. Function executes while run_flag.running.
Default new RunFlag
bt_device (string): Bluetooth device id
Yields:
tuple: MAC and State of RuuviTag sensor data
"""
mac_blacklist = Manager().list()
start_time = time.time()
data_iter = ble.get_datas(mac_blacklist, bt_device)
for ble_data in data_iter:
# Check duration
if search_duratio_sec and time.time(
) - start_time > search_duratio_sec:
data_iter.send(StopIteration)
break
# Check running flag
if not run_flag.running:
data_iter.send(StopIteration)
break
# Check MAC whitelist if advertised MAC available
if ble_data[0] and macs and not ble_data[0].upper() in map(
str.upper, macs):
continue
(data_format, data) = DataFormats.convert_data(ble_data[1])
# Check that encoded data is valid RuuviTag data and it is sensor data
# If data is not valid RuuviTag data add MAC to blacklist if MAC is available
if data is not None:
decoded = get_decoder(data_format).decode_data(data)
if decoded is not None:
# If advertised MAC is missing, try to parse it from the payload
mac = ble_data[0] if ble_data[0] else \
parse_mac(data_format, decoded['mac']) if decoded['mac'] else None
# Check whitelist using MAC from decoded data if advertised MAC is not available
if mac and macs and mac.upper() not in map(
str.upper, macs):
continue
yield (mac, decoded)
else:
log.error('Decoded data is null. MAC: %s - Raw: %s',
ble_data[0], ble_data[1])
else:
if ble_data[0]:
mac_blacklist.append(ble_data[0])
def collect_measurements(ruuvitags):
measurements = dict()
for mac, name in ruuvitags.items():
logger.info("Reading measurements from RuuviTag %s (%s)", name, mac)
(data_format, encoded) = RuuviTagSensor.get_data(mac)
if data_format is None or encoded is None:
logger.warning("Invalid data from RuuviTag %s", name)
continue
decoder = get_decoder(data_format)
data = decoder.decode_data(encoded)
logger.debug("Data received: %s", data)
data["name"] = name
measurements[mac] = data
return measurements
def _get_ruuvitag_datas(macs=[],
search_duratio_sec=None,
run_flag=RunFlag(),
bt_device=''):
"""
Get data from BluetoothCommunication and handle data encoding.
Args:
macs (list): MAC addresses. Default empty list
search_duratio_sec (int): Search duration in seconds. Default None
run_flag (object): RunFlag object. Function executes while run_flag.running.
Default new RunFlag
bt_device (string): Bluetooth device id
Yields:
tuple: MAC and State of RuuviTag sensor data
"""
mac_blacklist = []
start_time = time.time()
data_iter = ble.get_datas(mac_blacklist, bt_device)
for ble_data in data_iter:
# Check duration
if search_duratio_sec and time.time(
) - start_time > search_duratio_sec:
data_iter.send(StopIteration)
break
# Check running flag
if not run_flag.running:
data_iter.send(StopIteration)
break
# Check MAC whitelist
if macs and not ble_data[0] in macs:
continue
(data_format, data) = DataFormats.convert_data(ble_data[1])
# Check that encoded data is valid RuuviTag data and it is sensor data
# If data is not valid RuuviTag data add MAC to blacklist
if data is not None:
state = get_decoder(data_format).decode_data(data)
if state is not None:
yield (ble_data[0], state)
else:
log.error('Decoded data is null. MAC: %s - Raw: %s',
ble_data[0], ble_data[1])
else:
mac_blacklist.append(ble_data[0])
def update(self):
"""
Get lates data from the sensor and update own state.
Returns:
dict: Latest state
"""
(data_format, data) = RuuviTagSensor.get_data(self._mac)
if data == self._data:
return self._state
self._data = data
if self._data is None:
self._state = {}
else:
self._state = get_decoder(data_format).decode_data(self._data)
return self._state
def _get_ruuvitag_datas(macs=[],
search_duratio_sec=None,
run_flag=RunFlag()):
"""
Get data from BluetoothCommunication and handle data encoding.
Args:
macs (list): MAC addresses. Default empty list.
search_duratio_sec (int): Search duration in seconds. Default None.
run_flag (object): RunFlag object. Function executes while run_flag.running. Default new RunFlag.
Yields:
tuple: MAC and State of RuuviTag sensor data
"""
start_time = time.time()
data_iter = ble.get_datas()
for ble_data in data_iter:
# Check duration
if search_duratio_sec and time.time(
) - start_time > search_duratio_sec:
data_iter.send(StopIteration)
break
# Check running flag
if not run_flag.running:
data_iter.send(StopIteration)
break
# Check MAC whitelist
if macs and not ble_data[0] in macs:
continue
(data_format, data) = RuuviTagSensor.convert_data(ble_data[1])
# Check that encoded data is valid RuuviTag data and it is sensor data
if data is not None:
state = get_decoder(data_format).decode_data(data)
if state is not None:
yield (ble_data[0], state)
def test_getcorrectdecoder(self):
dec = get_decoder(2)
self.assertIsInstance(dec, UrlDecoder)
dec = get_decoder(3)
self.assertIsInstance(dec, Df3Decoder)
f = open("/home/pi/Desktop/beacon_scan/activeRpiStatusException.txt", "a")
f.write("------ Network issue " +
str(datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")) +
"-----\n")
f.close()
objConnectMqtt = connectMqtt()
objConnectMqtt.start()
client.loop_start()
for ble_data in ble.get_datas():
try:
if (len(ble_data[1]) == 66):
(data_format, encoded) = DataFormats.convert_data(ble_data[1])
if not (data_format == None or encoded == None):
sensor_data = get_decoder(data_format).decode_data(encoded)
sensor_data["rssi"] = int(ble_data[1][-2:], 16) - 256
sensor_data["battery"] = round(
giveBatteryPercentage(sensor_data["battery"]), 2)
sensor_data["timestamp"] = int(
datetime.datetime.now().timestamp() * 1000)
publish_array.append(sensor_data)
generateLowCriticalBatteryAlert(sensor_data)
generareAccelerometerAlert(sensor_data)
except Exception as err:
f = open("/home/pi/Desktop/beacon_scan/ruuviScannerExceptionLogs.txt",
"a")
f.write(
"temperature": payload["temperature"],
"humidity": payload["humidity"],
"pressure": payload["pressure"],
"battery": payload["battery"],
"acceleration": payload["acceleration"],
"acceleration_x": payload["acceleration_x"],
"acceleration_y": payload["acceleration_y"],
"acceleration_z": payload["acceleration_z"]
}
}
client = InfluxDBClient(host="localhost", port=8086, database="tag_data")
try:
client.create_database('tag_data')
except Exception as e:
print("Unable to create database", e, file=sys.stderr)
while True:
for mac, data in BleCommunicationBleson.get_datas():
#print(mac, data)
if data[0:2] == bytes.fromhex("9904") and data[2] == 3:
payload = get_decoder(3).decode_data(data[2:])
if payload is not None:
json_body = convert_to_influx(mac, payload)
if not args.quiet:
print(json_body)
if not args.test:
client.write_points([json_body])
