interier/apps/getData.py

import asyncio
from bleak import BleakClient, BleakScanner
from bleak.backends.characteristic import BleakGATTCharacteristic
import struct
import sqlite3
from dotenv import load_dotenv
import os

import smbus2
import bme280

# Initialise the BME280
port = 1
address = 0x76
bus = smbus2.SMBus(port)

calibration_params = bme280.load_calibration_params(bus, address)

load_dotenv()

outdoorName = os.getenv("BLE_PERIPHERAL_NAME")
outdoorConnected = 0

TEMP_UUID = "2A6E"
PRESSURE_UUID = "2A6D"
HUMIDITY_UUID = "2A6F"
ALTITUDE_UUID = "2AB3"

indoorValues = {
    "Temperature": 0,
    "Pressure": 0,
    "Humidity": 0,
    "Altitude": 0,
}

outdoorValues = {
    "Temperature": 0,
    "Pressure": 0,
    "Humidity": 0,
    "Altitude": 0,
}

def notification_handler(characteristic: BleakGATTCharacteristic, data: bytearray):
    global outdoorValues
    outdoorValues[characteristic.description] = struct.unpack("<i", data)[0]

async def ble_task():
    global outdoorConnected

    while True:
        disconnect_event = asyncio.Event()

        device = await BleakScanner.find_device_by_name(outdoorName)

        if device is None:
            outdoorConnected = 0

            print("no device found, wait then scan again")
            await asyncio.sleep(10)
            continue

        try:
            async with BleakClient(device, disconnected_callback=lambda c: disconnect_event.set()) as client:
                outdoorConnected = 1
                print(f"connected to {outdoorName}")

                await client.start_notify(TEMP_UUID, notification_handler)
                await client.start_notify(PRESSURE_UUID, notification_handler)
                await client.start_notify(HUMIDITY_UUID, notification_handler)
                await client.start_notify(ALTITUDE_UUID, notification_handler)

                await disconnect_event.wait()
        except Exception:
            outdoorConnected = 0
            print("exception while connecting or getting data")

async def sensor_task():
    global indoorValues
    
    while True:
        data = bme280.sample(bus, address, calibration_params)

        indoorValues["Temperature"] = round(data.temperature * 100)
        indoorValues["Pressure"] = round(data.pressure * 100)
        indoorValues["Humidity"] = round(data.humidity * 100)
        indoorValues["Altitude"] = 0 # * 100
        
        await asyncio.sleep(1)

conn = sqlite3.connect('./data/meteostanica.sqlite')
cursor = conn.cursor()

cursor.execute(
    """CREATE TABLE IF NOT EXISTS data (
        timestamp datetime default current_timestamp primary key,
        
        indoorTemp text not null,
        indoorPressure text not null,
        indoorHumidity text not null,
        indoorAltitude text not null,

        outdoorConnected integer not null,
        outdoorTemp text not null,
        outdoorPressure text not null,
        outdoorHumidity text not null,
        outdoorAltitude text not null
    );"""
)

conn.commit()

async def write_task():
    while True:
        cursor.execute(f"""INSERT INTO data (
            'indoorTemp', 'indoorPressure', 'indoorHumidity', 'indoorAltitude', 'outdoorConnected', 'outdoorTemp', 'outdoorPressure', 'outdoorHumidity', 'outdoorAltitude'
        ) VALUES (
            ?, ?, ?, ?, ?, ?, ?, ?, ?
        )""",
        (
            indoorValues["Temperature"], 
            indoorValues["Pressure"], 
            indoorValues["Humidity"], 
            indoorValues["Altitude"],
            outdoorConnected,
            outdoorValues["Temperature"], 
            outdoorValues["Pressure"], 
            outdoorValues["Humidity"], 
            outdoorValues["Altitude"]
        ))

        conn.commit()

        print(f"indoor: {indoorValues["Temperature"] / 100}°C, outdoor: {outdoorConnected} - {outdoorValues["Temperature"] / 100}°C")

        await asyncio.sleep(10)

async def main():
    try:
        t1 = asyncio.create_task(ble_task())
        t2 = asyncio.create_task(sensor_task())
        t3 = asyncio.create_task(write_task())
        await asyncio.gather(t1, t2, t3)
    except asyncio.exceptions.CancelledError:
        pass
    
asyncio.run(main())