ESP32 BLE Random Value + LED Control
+ +
+
+
+
+
+
+
+
+
+ Device: —
+ Connection: disconnected
+
+
+
+ Random value (notify):
+ —
+
+
+
+ LED command (write):
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_Sort/BLE_Example.py b/_Sort/BLE_Example.py
new file mode 100644
index 0000000..9db974e
--- /dev/null
+++ b/_Sort/BLE_Example.py
@@ -0,0 +1,130 @@
+# Rui Santos & Sara Santos - Random Nerd Tutorials
+# Complete project details at https://RandomNerdTutorials.com/micropython-esp32-bluetooth-low-energy-ble/
+
+from micropython import const
+import asyncio
+import aioble
+import bluetooth
+import struct
+from machine import Pin
+from random import randint
+import machine, neopixel
+
+n = 1
+p = 8
+
+np = neopixel.NeoPixel(machine.Pin(p), n)
+
+np[0] = (255, 0, 0)
+np.write()
+
+# Init random value
+value = 0
+
+# See the following for generating UUIDs:
+# https://www.uuidgenerator.net/
+_BLE_SERVICE_UUID = bluetooth.UUID('19b10000-e8f2-537e-4f6c-d104768a1214')
+_BLE_SENSOR_CHAR_UUID = bluetooth.UUID('19b10001-e8f2-537e-4f6c-d104768a1214')
+_BLE_LED_UUID = bluetooth.UUID('19b10002-e8f2-537e-4f6c-d104768a1214')
+# How frequently to send advertising beacons.
+_ADV_INTERVAL_MS = 250_000
+
+# Register GATT server, the service and characteristics
+ble_service = aioble.Service(_BLE_SERVICE_UUID)
+sensor_characteristic = aioble.Characteristic(ble_service, _BLE_SENSOR_CHAR_UUID, read=True, notify=True)
+led_characteristic = aioble.Characteristic(ble_service, _BLE_LED_UUID, read=True, write=True, notify=True, capture=True)
+
+# Register service(s)
+aioble.register_services(ble_service)
+
+# Helper to encode the data characteristic UTF-8
+def _encode_data(data):
+ return str(data).encode('utf-8')
+
+# Helper to decode the LED characteristic encoding (bytes).
+def _decode_data(data):
+ try:
+ if data is not None:
+ # Decode the UTF-8 data
+ number = int.from_bytes(data, 'big')
+ return number
+ except Exception as e:
+ print("Error decoding temperature:", e)
+ return None
+
+# Get sensor readings
+def get_random_value():
+ return randint(0,100)
+
+# Get new value and update characteristic
+async def sensor_task():
+ while True:
+ value = get_random_value()
+ sensor_characteristic.write(_encode_data(value), send_update=True)
+ print('New random value written: ', value)
+ await asyncio.sleep_ms(1000)
+
+# Serially wait for connections. Don't advertise while a central is connected.
+async def peripheral_task():
+ while True:
+ try:
+ async with await aioble.advertise(
+ _ADV_INTERVAL_MS,
+ name="ESP32",
+ services=[_BLE_SERVICE_UUID],
+ ) as connection:
+ print("Connection from", connection.device)
+ await connection.disconnected()
+ except asyncio.CancelledError:
+ # Catch the CancelledError
+ print("Peripheral task cancelled")
+ except Exception as e:
+ print("Error in peripheral_task:", e)
+ finally:
+ # Ensure the loop continues to the next iteration
+ await asyncio.sleep_ms(100)
+
+async def wait_for_write():
+ while True:
+ try:
+ connection, data = await led_characteristic.written()
+ print(data)
+ print(type)
+ data = _decode_data(data)
+ print('Connection: ', connection)
+ print('Data: ', data)
+ if data == 0:
+ print('Turning LED OFF')
+ np[0] = (0, 0, 0)
+ np.write()
+ elif data == 1:
+ print('Turning LED RED')
+ np[0] = (255, 0, 0)
+ np.write()
+ elif data == 2:
+ print('Turning LED GREEN')
+ np[0] = (0, 255, 0)
+ np.write()
+ elif data == 3:
+ print('Turning LED BLUE')
+ np[0] = (0, 0, 255)
+ np.write()
+ else:
+ print('Unknown command')
+ except asyncio.CancelledError:
+ # Catch the CancelledError
+ print("Peripheral task cancelled")
+ except Exception as e:
+ print("Error in peripheral_task:", e)
+ finally:
+ # Ensure the loop continues to the next iteration
+ await asyncio.sleep_ms(100)
+
+# Run tasks
+async def main():
+ t1 = asyncio.create_task(sensor_task())
+ t2 = asyncio.create_task(peripheral_task())
+ t3 = asyncio.create_task(wait_for_write())
+ await asyncio.gather(t1, t2)
+
+asyncio.run(main())
\ No newline at end of file
diff --git a/_Sort/BME680.py b/_Sort/BME680.py
new file mode 100644
index 0000000..518ffb5
--- /dev/null
+++ b/_Sort/BME680.py
@@ -0,0 +1,156 @@
+from micropython import const
+import asyncio
+import aioble
+import bluetooth
+import machine
+import neopixel
+import ujson as json
+import time
+import _thread
+
+from machine import Pin, I2C
+import bme680
+
+# ----------------- NeoPixel -----------------
+NEO_PIN = 8
+NEO_COUNT = 1
+np = neopixel.NeoPixel(machine.Pin(NEO_PIN), NEO_COUNT)
+np[0] = (127, 0, 127)
+np.write()
+
+def set_led(cmd: int):
+ if cmd == 0:
+ np[0] = (0, 0, 0)
+ elif cmd == 1:
+ np[0] = (255, 0, 0)
+ elif cmd == 2:
+ np[0] = (0, 255, 0)
+ elif cmd == 3:
+ np[0] = (0, 0, 255)
+ else:
+ return
+ np.write()
+
+def decode_cmd(data: bytes):
+ try:
+ if data is None:
+ return None
+ return int.from_bytes(data, "big")
+ except:
+ return None
+
+# ----------------- I2C + BME680 -----------------
+# Your wiring: GPIO5=SCL, GPIO4=SDA
+i2c = I2C(0, scl=Pin(5), sda=Pin(4), freq=400_000)
+sensor = bme680.BME680(i2c)
+
+# Shared sensor data (written by thread, read by asyncio)
+_lock = _thread.allocate_lock()
+_latest = {
+ "t_c": None,
+ "h_pct": None,
+ "p_hpa": None,
+ "gas_ohms": None,
+ "gas_valid": True,
+ "ts": 0,
+}
+
+def bme680_thread():
+ i = 0
+ while True:
+ i += 1
+
+ # Gas is slow: do it every 10 seconds
+ gas_on = (i % 10 == 0)
+
+ # Fast settings for demo
+ sensor.measure(
+ gas=gas_on,
+ t_os=1, p_os=1, h_os=1,
+ iir_filter=0,
+ gas_temp=300,
+ gas_ms=80
+ )
+ #sensor.measure(gas=True)
+ t = sensor.temperature()
+ h = sensor.humidity()
+ p = sensor.pressure()
+ g = sensor.gas() if gas_on else {"ohms": None, "valid": False}
+
+ with _lock:
+ _latest["t_c"] = round(t, 2)
+ _latest["h_pct"] = round(h, 2)
+ _latest["p_hpa"] = round(p, 2)
+ _latest["gas_ohms"] = g["ohms"]
+ _latest["gas_valid"] = bool(g["valid"])
+ _latest["ts"] = time.time()
+
+ time.sleep(1)
+
+_thread.start_new_thread(bme680_thread, ())
+
+# ----------------- BLE UUIDs -----------------
+_BLE_SERVICE_UUID = bluetooth.UUID("19b10000-e8f2-537e-4f6c-d104768a1214")
+_BLE_SENSOR_CHAR_UUID = bluetooth.UUID("19b10001-e8f2-537e-4f6c-d104768a1214") # notify
+_BLE_LED_CHAR_UUID = bluetooth.UUID("19b10002-e8f2-537e-4f6c-d104768a1214") # write
+
+_ADV_INTERVAL_MS = const(250_000)
+
+ble_service = aioble.Service(_BLE_SERVICE_UUID)
+sensor_characteristic = aioble.Characteristic(ble_service, _BLE_SENSOR_CHAR_UUID, read=True, notify=True)
+led_characteristic = aioble.Characteristic(ble_service, _BLE_LED_CHAR_UUID, read=True, write=True, capture=True)
+aioble.register_services(ble_service)
+
+def encode_json(obj) -> bytes:
+ return json.dumps(obj).encode("utf-8")
+
+# ----------------- BLE tasks -----------------
+async def notify_task():
+ last = None
+ while True:
+ with _lock:
+ payload = dict(_latest)
+
+ b = encode_json(payload)
+ if b != last:
+ sensor_characteristic.write(b, send_update=True)
+ last = b
+
+ await asyncio.sleep_ms(500) # UI feels live at 2 Hz
+
+async def peripheral_task():
+ while True:
+ try:
+ async with await aioble.advertise(
+ _ADV_INTERVAL_MS,
+ name="ESP32-BME680",
+ services=[_BLE_SERVICE_UUID],
+ ) as connection:
+ print("Connection from", connection.device)
+ await connection.disconnected()
+ print("Disconnected")
+ except Exception as e:
+ print("peripheral_task error:", e)
+ await asyncio.sleep_ms(200)
+
+async def led_write_task():
+ while True:
+ try:
+ connection, data = await led_characteristic.written()
+ cmd = decode_cmd(data)
+ print("LED cmd:", cmd, "from", connection.device)
+ if cmd is not None:
+ set_led(cmd)
+ except Exception as e:
+ print("led_write_task error:", e)
+ await asyncio.sleep_ms(100)
+
+async def main():
+ await asyncio.gather(
+ notify_task(),
+ peripheral_task(),
+ led_write_task()
+ )
+
+asyncio.run(main())
+
diff --git a/_Sort/BME680Index - Copy.html b/_Sort/BME680Index - Copy.html
new file mode 100644
index 0000000..289a0ec
--- /dev/null
+++ b/_Sort/BME680Index - Copy.html
@@ -0,0 +1,186 @@
+
+
+
+
+
+ Log
+
+ ESP32 BME680 (BLE)
+ +
+
+
+
+
+ Device: —
+ Connection: disconnected
+
+
+
+
+
+ Temperature
+ — °C
+
+
+ Humidity
+ — %
+
+
+ Pressure
+ — hPa
+
+
+ Gas Resistance
+ — Ω
+ Valid: —
+
+
+
+ LED Control
+
+
+
+
+
+
+
+
+
+
diff --git a/_Sort/BME680Index.html b/_Sort/BME680Index.html
new file mode 100644
index 0000000..289a0ec
--- /dev/null
+++ b/_Sort/BME680Index.html
@@ -0,0 +1,186 @@
+
+
+
+
+
+ Log
+
+ ESP32 BME680 (BLE)
+ +
+
+
+
+
+ Device: —
+ Connection: disconnected
+
+
+
+
+
+ Temperature
+ — °C
+
+
+ Humidity
+ — %
+
+
+ Pressure
+ — hPa
+
+
+ Gas Resistance
+ — Ω
+ Valid: —
+
+
+
+ LED Control
+
+
+
+
+
+
+
+
+
+
diff --git a/_Sort/BothSensorsIndex.html b/_Sort/BothSensorsIndex.html
new file mode 100644
index 0000000..83b5715
--- /dev/null
+++ b/_Sort/BothSensorsIndex.html
@@ -0,0 +1,212 @@
+
+
+
+
+
+ Log
+
+ ESP32 BME680 + ADXL345 (BLE)
+ +
+
+
+
+
+ Device: —
+ Connection: disconnected
+
+
+
+
+
+ Temperature
+ — °C
+
+
+ Humidity
+ — %
+
+
+ Pressure
+ — hPa
+
+
+
+ Gas Resistance
+ — Ω
+ Valid: —
+
+
+ ADXL345
+ Shake: —
+ ax=— g ay=— g az=— g
+
+
+
+ LED Control
+
+
+
+
+
+
+
+
+
diff --git a/_Sort/ModbusRTU_BME680/ModbusRTU_BME680.ino b/_Sort/ModbusRTU_BME680/ModbusRTU_BME680.ino
new file mode 100644
index 0000000..9f127ca
--- /dev/null
+++ b/_Sort/ModbusRTU_BME680/ModbusRTU_BME680.ino
@@ -0,0 +1,33 @@
+#include Log
+
+ 🛡️ Phoenix Guardian 🔥
+Environmental and vibration monitoring prototype
+ +
+
+
+
+
+
+
+
+
+
+ Project description
+ ++ + Guardian Phoenix is a monitoring prototype designed for remote sites without electrical infrastructure. The system simulates physical sensors using the sensors of a mobile phone. + +
+ ++ + The device's battery represents the system's backup battery, while the connection to an electrical source simulates an active solar panel. + +
+ +
+
+
+
+Energy state
+ +System battery: 100 %
+ +Power source: Active solar panel
+ +
+
+
+
+
+
+
+
+
+
+ Environmental Sensor
+ +Temperature: -- °C
+ +Humidity: -- %
+ +Pressure: -- hPa
+ + + + + +
+
+
+
+ Vibration Sensor
+ +Vibration: 0.00
+ +Steady state
+ + + +
+
+ 🚨 Dangerous vibration detected
+ + + +
+
+ + + + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+Records
+ +| Hour | + +Temp | + +Hum | + +President | + +Event | + +
|---|
+
+
+
+
+
+
+
+
+
+ Humidity
+ + + +
+
+
+
+ Temperature
+ + + +
+
+
+
+Pressure
+ + + +
Original text
Rate this translation
Your feedback will be used to help improve Google Translate
🛡️ Guardián Fénix 🔥
+Prototipo de monitoreo ambiental y vibración
+ +
+
+
+
+
+
+
+
+
+
+ Descripción del proyecto
+ ++ + Guardián Fénix es un prototipo de monitoreo diseñado para sitios remotos + + sin infraestructura eléctrica. El sistema simula sensores físicos + + utilizando los sensores del teléfono móvil. + +
+ ++ + La batería del dispositivo representa la batería de respaldo del sistema, + + mientras que la conexión a una fuente eléctrica simula un panel solar activo. + +
+ +
+
+
+
+Estado de energía
+ +Batería del sistema: --%
+ +Fuente de energía: --
+ +
+
+
+
+
+
+
+
+
+
+ Sensor Ambiental
+ +Temperatura: -- °C
+ +Humedad: -- %
+ +Presión: -- hPa
+ + + + + +
+
+
+
+ Sensor de Vibración
+ +Vibración: 0.00
+ +Estado: Estable
+ + + +
+
+ 🚨 Vibración peligrosa detectada
+ + + +
+
+ + + + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+Registros
+ +| Hora | + +Temp | + +Hum | + +Pres | + +Evento | + +
|---|
+
+
+
+
+
+
+
+
+
+
diff --git a/_Sort/_/17_CameraShortCut/index_NEW.html b/_Sort/_/17_CameraShortCut/index_NEW.html
new file mode 100644
index 0000000..694ef1f
--- /dev/null
+++ b/_Sort/_/17_CameraShortCut/index_NEW.html
@@ -0,0 +1,253 @@
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/_Sort/_/17_CameraShortCut/index_OLD.html b/_Sort/_/17_CameraShortCut/index_OLD.html
new file mode 100644
index 0000000..23dab90
--- /dev/null
+++ b/_Sort/_/17_CameraShortCut/index_OLD.html
@@ -0,0 +1,226 @@
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/_Sort/ble/V001.py b/_Sort/ble/V001.py
new file mode 100644
index 0000000..a7f8d5b
--- /dev/null
+++ b/_Sort/ble/V001.py
@@ -0,0 +1,19 @@
+import asyncio
+from bleak import BleakScanner, BleakClient
+
+SERVICE_UUID = "7e2a0001-1111-2222-3333-444455556666"
+CHAR_UUID = "7e2a0002-1111-2222-3333-444455556666"
+
+def handle_notify(sender, data):
+ text = data.decode(errors="ignore")
+ print("RX:", text)
+
+async def main():
+ print("Connecting to", "10:51:DB:1B:E7:1E")
+
+ async with BleakClient("10:51:DB:1B:E7:1E") as client:
+ print("Connected")
+ await client.start_notify(CHAR_UUID, handle_notify)
+ await asyncio.sleep(120) # run for 1 minute
+
+asyncio.run(main())
diff --git a/_Sort/ble/V002.py b/_Sort/ble/V002.py
new file mode 100644
index 0000000..4f0c2f9
--- /dev/null
+++ b/_Sort/ble/V002.py
@@ -0,0 +1,87 @@
+import pygame
+import math
+
+pygame.init()
+pygame.joystick.init()
+
+if pygame.joystick.get_count() == 0:
+ raise SystemExit("No controller detected. Plug in DualSense via USB first (recommended).")
+
+js = pygame.joystick.Joystick(0)
+js.init()
+
+W, H = 900, 500
+screen = pygame.display.set_mode((W, H))
+pygame.display.set_caption(f"Controller Visualizer: {js.get_name()}")
+clock = pygame.time.Clock()
+font = pygame.font.SysFont(None, 24)
+
+def clamp01(x): return max(0.0, min(1.0, x))
+
+def draw_text(x, y, s):
+ screen.blit(font.render(s, True, (230, 230, 230)), (x, y))
+
+def draw_stick(cx, cy, r, x, y, label):
+ # x,y expected in [-1,1]
+ pygame.draw.circle(screen, (80,80,80), (cx, cy), r, 2)
+ px = int(cx + x * (r - 6))
+ py = int(cy + y * (r - 6))
+ pygame.draw.circle(screen, (200,200,200), (px, py), 6)
+ draw_text(cx - r, cy + r + 8, f"{label}: x={x:+.2f} y={y:+.2f}")
+
+def draw_bar(x, y, w, h, v, label):
+ # v in [0,1]
+ pygame.draw.rect(screen, (80,80,80), (x,y,w,h), 2)
+ fill = int(w * clamp01(v))
+ pygame.draw.rect(screen, (200,200,200), (x,y,fill,h))
+ draw_text(x, y - 22, f"{label}: {v:.2f}")
+
+def draw_button(x, y, on, label):
+ col = (70,200,90) if on else (100,100,100)
+ pygame.draw.circle(screen, col, (x, y), 14)
+ draw_text(x + 22, y - 10, label)
+
+# Axis indices vary by OS/driver. We’ll read a bunch and print them.
+print("Axes:", js.get_numaxes(), "Buttons:", js.get_numbuttons(), "Hats:", js.get_numhats())
+
+running = True
+while running:
+ for e in pygame.event.get():
+ if e.type == pygame.QUIT:
+ running = False
+
+ pygame.event.pump()
+ screen.fill((20, 20, 24))
+
+ # Common mappings (may differ):
+ lx = js.get_axis(0)
+ ly = js.get_axis(1)
+ rx = js.get_axis(2) if js.get_numaxes() > 2 else 0.0
+ ry = js.get_axis(3) if js.get_numaxes() > 3 else 0.0
+
+ # Triggers sometimes appear as axes, sometimes buttons; try axes 4/5 if present:
+ lt = (js.get_axis(4) + 1) / 2 if js.get_numaxes() > 4 else 0.0
+ rt = (js.get_axis(5) + 1) / 2 if js.get_numaxes() > 5 else 0.0
+
+ draw_stick(200, 220, 90, lx, ly, "Left stick")
+ draw_stick(450, 220, 90, rx, ry, "Right stick")
+ draw_bar(650, 150, 200, 24, lt, "L2")
+ draw_bar(650, 220, 200, 24, rt, "R2")
+
+ # Buttons (indices vary). We'll show first 12 if present:
+ for i in range(min(12, js.get_numbuttons())):
+ on = bool(js.get_button(i))
+ draw_button(650 + (i % 6) * 40, 300 + (i // 6) * 50, on, str(i))
+
+ # Hat (D-pad)
+ if js.get_numhats() > 0:
+ hx, hy = js.get_hat(0)
+ draw_text(650, 400, f"D-pad (hat0): {hx},{hy}")
+
+ draw_text(20, 20, f"Device: {js.get_name()}")
+ draw_text(20, 46, "Tip: If axes look wrong, mapping differs on your OS. USB is easiest.")
+
+ pygame.display.flip()
+ clock.tick(60)
+
+pygame.quit()
diff --git a/_Sort/ble/V003.py b/_Sort/ble/V003.py
new file mode 100644
index 0000000..feac38e
--- /dev/null
+++ b/_Sort/ble/V003.py
@@ -0,0 +1,142 @@
+import asyncio
+import math
+import time
+import threading
+
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from bleak import BleakClient
+
+# ====== HARD-CODED DEVICE ======
+ADDRESS = "10:51:DB:1B:E7:1E"
+
+# ====== ADXL345 CHARACTERISTIC UUID ======
+CHAR_UUID = "7e2a1002-1111-2222-3333-444455556666"
+
+# Plot refresh interval (ms)
+PLOT_INTERVAL_MS = 50
+
+latest = {
+ "ax": 0.0,
+ "ay": 0.0,
+ "az": 1.0,
+ "ts": 0.0,
+ "raw": "",
+ "count": 0,
+}
+
+def parse_csv_triplet(s: str):
+ s = s.strip().strip('"')
+ parts = s.split(",")
+ if len(parts) != 3:
+ return None
+ try:
+ return float(parts[0]), float(parts[1]), float(parts[2])
+ except ValueError:
+ return None
+
+def roll_pitch_from_accel(ax, ay, az):
+ roll = math.degrees(math.atan2(ay, az))
+ pitch = math.degrees(math.atan2(-ax, math.sqrt(ay * ay + az * az)))
+ return roll, pitch
+
+def notify_handler(_sender: int, data: bytearray):
+ s = data.decode(errors="ignore").strip()
+ latest["raw"] = s
+
+ v = parse_csv_triplet(s)
+ if v is None:
+ return
+
+ ax, ay, az = v
+ latest["ax"], latest["ay"], latest["az"] = ax, ay, az
+ latest["ts"] = time.time()
+ latest["count"] += 1
+
+ # Debug print every 5 packets (avoid flooding)
+ if latest["count"] % 5 == 0:
+ print(f"RX[{latest['count']}]: {ax:+.4f}, {ay:+.4f}, {az:+.4f}")
+
+async def ble_loop():
+ while True:
+ try:
+ print(f"Connecting to {ADDRESS} ...")
+ async with BleakClient(ADDRESS, timeout=15.0) as client:
+ if not client.is_connected:
+ raise RuntimeError("Connect failed (not connected).")
+
+ print("Connected.")
+ print("Subscribing to notifications...")
+ await client.start_notify(CHAR_UUID, notify_handler)
+ print("Notify enabled. Streaming...\n")
+
+ while True:
+ await asyncio.sleep(1.0)
+
+ except Exception as e:
+ print(f"[BLE] Error/disconnect: {e}")
+ print("Reconnecting in 2 seconds...\n")
+ await asyncio.sleep(2.0)
+
+def start_ble_thread():
+ t = threading.Thread(target=lambda: asyncio.run(ble_loop()), daemon=True)
+ t.start()
+
+def main():
+ print("IMPORTANT: Disconnect nRF Connect (or any other BLE client) first.")
+ start_ble_thread()
+
+ # --- Matplotlib setup ---
+ fig = plt.figure()
+ ax3 = fig.add_subplot(111, projection="3d")
+ ax3.set_title("ADXL345 live acceleration vector (g)")
+
+ lim = 2.0
+ ax3.set_xlim(-lim, lim)
+ ax3.set_ylim(-lim, lim)
+ ax3.set_zlim(-lim, lim)
+ ax3.set_xlabel("X (g)")
+ ax3.set_ylabel("Y (g)")
+ ax3.set_zlabel("Z (g)")
+
+ # Axes lines
+ ax3.plot([-lim, lim], [0, 0], [0, 0])
+ ax3.plot([0, 0], [-lim, lim], [0, 0])
+ ax3.plot([0, 0], [0, 0], [-lim, lim])
+
+ # Initial arrow + overlay
+ q = ax3.quiver(0, 0, 0, 0, 0, 1, length=1.0, normalize=False)
+ overlay = ax3.text2D(0.02, 0.95, "Waiting for data...", transform=ax3.transAxes)
+
+ def update(_frame):
+ nonlocal q
+
+ # Remove old arrow
+ try:
+ q.remove()
+ except Exception:
+ pass
+
+ vx, vy, vz = latest["ax"], latest["ay"], latest["az"]
+ roll, pitch = roll_pitch_from_accel(vx, vy, vz)
+ age_ms = (time.time() - latest["ts"]) * 1000.0 if latest["ts"] else float("inf")
+
+ # Draw new arrow
+ q = ax3.quiver(0, 0, 0, vx, vy, vz, length=1.0, normalize=False)
+
+ overlay.set_text(
+ f"packets: {latest['count']}\n"
+ f"ax={vx:+.4f} ay={vy:+.4f} az={vz:+.4f} (g)\n"
+ f"roll={roll:+.1f}° pitch={pitch:+.1f}° age={age_ms:.0f} ms\n"
+ f"raw: {latest['raw']}"
+ )
+
+ return q, overlay
+
+ # KEY FIX: keep this object alive
+ ani = FuncAnimation(fig, update, interval=PLOT_INTERVAL_MS, blit=False)
+
+ plt.show()
+
+if __name__ == "__main__":
+ main()
diff --git a/_Sort/ble/V004.py b/_Sort/ble/V004.py
new file mode 100644
index 0000000..a79582b
--- /dev/null
+++ b/_Sort/ble/V004.py
@@ -0,0 +1,165 @@
+# V005.py (VERSION: QT-ORDER-FIX-1)
+print("=== V005 VERSION: QT-ORDER-FIX-1 ===")
+
+import sys
+
+# ✅ MUST create QApplication BEFORE any QWidget exists
+from PyQt5 import QtWidgets, QtCore
+app = QtWidgets.QApplication.instance()
+if app is None:
+ app = QtWidgets.QApplication(sys.argv)
+
+# Now it is safe to import pyqtgraph / OpenGL stuff
+import asyncio
+import math
+import time
+import threading
+import numpy as np
+
+import pyqtgraph.opengl as gl
+from bleak import BleakClient
+
+# ====== HARD-CODED DEVICE ======
+ADDRESS = "10:51:DB:1B:E7:1E"
+CHAR_UUID = "7e2a1002-1111-2222-3333-444455556666"
+
+latest = {"ax": 0.0, "ay": 0.0, "az": 1.0, "ts": 0.0, "count": 0, "raw": ""}
+
+def parse_csv_triplet(s: str):
+ s = s.strip().strip('"')
+ parts = s.split(",")
+ if len(parts) != 3:
+ return None
+ try:
+ return float(parts[0]), float(parts[1]), float(parts[2])
+ except ValueError:
+ return None
+
+def notify_handler(_sender: int, data: bytearray):
+ s = data.decode(errors="ignore").strip()
+ latest["raw"] = s
+ v = parse_csv_triplet(s)
+ if v is None:
+ return
+ latest["ax"], latest["ay"], latest["az"] = v
+ latest["ts"] = time.time()
+ latest["count"] += 1
+
+def roll_pitch_from_accel(ax, ay, az):
+ roll = math.degrees(math.atan2(ay, az))
+ pitch = math.degrees(math.atan2(-ax, math.sqrt(ay * ay + az * az)))
+ return roll, pitch
+
+async def ble_loop():
+ while True:
+ try:
+ print(f"Connecting to {ADDRESS} ...")
+ async with BleakClient(ADDRESS, timeout=15.0) as client:
+ if not client.is_connected:
+ raise RuntimeError("Connect failed.")
+ print("Connected. Enabling notifications...")
+ await client.start_notify(CHAR_UUID, notify_handler)
+ print("Notify enabled. Streaming...\n")
+ while True:
+ await asyncio.sleep(1.0)
+ except Exception as e:
+ print(f"[BLE] Error/disconnect: {e}")
+ print("Reconnecting in 2 seconds...\n")
+ await asyncio.sleep(2.0)
+
+def start_ble_thread():
+ t = threading.Thread(target=lambda: asyncio.run(ble_loop()), daemon=True)
+ t.start()
+
+def make_cuboid(size=(2.0, 1.2, 0.1)):
+ L, W, T = size
+ x, y, z = L/2, W/2, T/2
+ verts = np.array([
+ [-x,-y,-z], [ x,-y,-z], [ x, y,-z], [-x, y,-z],
+ [-x,-y, z], [ x,-y, z], [ x, y, z], [-x, y, z],
+ ], dtype=float)
+ faces = np.array([
+ [0,1,2],[0,2,3],
+ [4,6,5],[4,7,6],
+ [0,4,5],[0,5,1],
+ [1,5,6],[1,6,2],
+ [2,6,7],[2,7,3],
+ [3,7,4],[3,4,0],
+ ], dtype=int)
+ return verts, faces
+
+class Viewer(QtWidgets.QMainWindow):
+ def __init__(self):
+ super().__init__()
+ self.setWindowTitle("ADXL345 – 3D PCB Tilt (BLE)")
+
+ self.view = gl.GLViewWidget()
+ self.view.setCameraPosition(distance=6, elevation=25, azimuth=40)
+ self.setCentralWidget(self.view)
+
+ grid = gl.GLGridItem()
+ grid.setSize(10, 10)
+ grid.setSpacing(1, 1)
+ self.view.addItem(grid)
+
+ axis = gl.GLAxisItem()
+ axis.setSize(2, 2, 2)
+ self.view.addItem(axis)
+
+ verts, faces = make_cuboid()
+ colors = np.ones((faces.shape[0], 4), dtype=float)
+ colors[:,0]=0.25; colors[:,1]=0.7; colors[:,2]=0.35; colors[:,3]=0.9
+
+ meshdata = gl.MeshData(vertexes=verts, faces=faces)
+ self.mesh = gl.GLMeshItem(meshdata=meshdata, faceColors=colors, drawEdges=True, edgeColor=(0,0,0,1))
+ self.view.addItem(self.mesh)
+
+ self.vec = gl.GLLinePlotItem(pos=np.array([[0,0,0],[0,0,1]]), width=3, antialias=True)
+ self.view.addItem(self.vec)
+
+ self.label = QtWidgets.QLabel(self)
+ self.label.setStyleSheet("color:white; background:rgba(0,0,0,140); padding:6px;")
+ self.label.move(10, 10)
+ self.label.resize(440, 90)
+
+ self.roll = 0.0
+ self.pitch = 0.0
+
+ self.timer = QtCore.QTimer()
+ self.timer.timeout.connect(self.update_scene)
+ self.timer.start(20)
+
+ def update_scene(self):
+ axg, ayg, azg = latest["ax"], latest["ay"], latest["az"]
+ roll, pitch = roll_pitch_from_accel(axg, ayg, azg)
+
+ alpha = 0.15
+ self.roll = (1-alpha)*self.roll + alpha*roll
+ self.pitch = (1-alpha)*self.pitch + alpha*pitch
+
+ self.mesh.resetTransform()
+ self.mesh.rotate(self.pitch, 0, 1, 0)
+ self.mesh.rotate(self.roll, 1, 0, 0)
+
+ self.vec.setData(pos=np.array([[0,0,0],[axg, ayg, azg]], dtype=float))
+
+ age = (time.time()-latest["ts"])*1000 if latest["ts"] else 0
+ self.label.setText(
+ f"Packets: {latest['count']} Age: {age:.0f} ms\n"
+ f"ax={axg:+.3f}g ay={ayg:+.3f}g az={azg:+.3f}g\n"
+ f"roll={self.roll:+.1f}° pitch={self.pitch:+.1f}°\n"
+ f"raw: {latest['raw']}"
+ )
+
+def main():
+ print("IMPORTANT: Disconnect nRF Connect (or any other BLE client) first.")
+ start_ble_thread()
+
+ win = Viewer()
+ win.resize(900, 650)
+ win.show()
+
+ sys.exit(app.exec_())
+
+if __name__ == "__main__":
+ main()
diff --git a/_Sort/ble/V005.py b/_Sort/ble/V005.py
new file mode 100644
index 0000000..e3d625d
--- /dev/null
+++ b/_Sort/ble/V005.py
@@ -0,0 +1,225 @@
+# V005.py (VERSION: 3D-PCB+GRAPH-1)
+print("=== V005 VERSION: 3D-PCB+GRAPH-1 ===")
+
+import sys
+import time
+import math
+import asyncio
+import threading
+
+import numpy as np
+from bleak import BleakClient
+
+from PyQt5 import QtWidgets, QtCore
+import pyqtgraph as pg
+import pyqtgraph.opengl as gl
+
+# ====== HARD-CODED DEVICE ======
+ADDRESS = "10:51:DB:1B:E7:1E"
+CHAR_UUID = "7e2a1002-1111-2222-3333-444455556666"
+
+# ====== GRAPH SETTINGS ======
+HISTORY_SECONDS = 10.0 # how many seconds of history to show
+GRAPH_UPDATE_MS = 50 # graph refresh rate
+MAX_G = 4.0 # y-axis range for graph
+
+# Shared latest values (written by BLE notify, read by UI)
+latest = {"ax": 0.0, "ay": 0.0, "az": 1.0, "ts": 0.0, "count": 0, "raw": ""}
+
+# Ring buffer for plotting
+t_buf = []
+ax_buf = []
+ay_buf = []
+az_buf = []
+
+def parse_csv_triplet(s: str):
+ s = s.strip().strip('"')
+ parts = s.split(",")
+ if len(parts) != 3:
+ return None
+ try:
+ return float(parts[0]), float(parts[1]), float(parts[2])
+ except ValueError:
+ return None
+
+def notify_handler(_sender: int, data: bytearray):
+ s = data.decode(errors="ignore").strip()
+ latest["raw"] = s
+ v = parse_csv_triplet(s)
+ if v is None:
+ return
+ latest["ax"], latest["ay"], latest["az"] = v
+ latest["ts"] = time.time()
+ latest["count"] += 1
+
+def roll_pitch_from_accel(ax, ay, az):
+ roll = math.degrees(math.atan2(ay, az))
+ pitch = math.degrees(math.atan2(-ax, math.sqrt(ay * ay + az * az)))
+ return roll, pitch
+
+async def ble_loop():
+ while True:
+ try:
+ print(f"Connecting to {ADDRESS} ...")
+ async with BleakClient(ADDRESS, timeout=15.0) as client:
+ if not client.is_connected:
+ raise RuntimeError("Connect failed.")
+ print("Connected. Enabling notifications...")
+ await client.start_notify(CHAR_UUID, notify_handler)
+ print("Notify enabled. Streaming...\n")
+ while True:
+ await asyncio.sleep(1.0)
+ except Exception as e:
+ print(f"[BLE] Error/disconnect: {e}")
+ print("Reconnecting in 2 seconds...\n")
+ await asyncio.sleep(2.0)
+
+def start_ble_thread():
+ t = threading.Thread(target=lambda: asyncio.run(ble_loop()), daemon=True)
+ t.start()
+
+def make_cuboid(size=(2.0, 1.2, 0.1)):
+ L, W, T = size
+ x, y, z = L/2, W/2, T/2
+ verts = np.array([
+ [-x,-y,-z], [ x,-y,-z], [ x, y,-z], [-x, y,-z],
+ [-x,-y, z], [ x,-y, z], [ x, y, z], [-x, y, z],
+ ], dtype=float)
+ faces = np.array([
+ [0,1,2],[0,2,3],
+ [4,6,5],[4,7,6],
+ [0,4,5],[0,5,1],
+ [1,5,6],[1,6,2],
+ [2,6,7],[2,7,3],
+ [3,7,4],[3,4,0],
+ ], dtype=int)
+ return verts, faces
+
+class MainWindow(QtWidgets.QMainWindow):
+ def __init__(self):
+ super().__init__()
+ self.setWindowTitle("ADXL345 – 3D PCB + Live Accel Graph (BLE)")
+
+ # ---- Layout container ----
+ central = QtWidgets.QWidget()
+ self.setCentralWidget(central)
+ vbox = QtWidgets.QVBoxLayout(central)
+ vbox.setContentsMargins(6, 6, 6, 6)
+ vbox.setSpacing(6)
+
+ # ---- 3D view ----
+ self.view3d = gl.GLViewWidget()
+ self.view3d.setMinimumHeight(430)
+ self.view3d.setCameraPosition(distance=6, elevation=25, azimuth=40)
+ vbox.addWidget(self.view3d, stretch=3)
+
+ grid = gl.GLGridItem()
+ grid.setSize(10, 10)
+ grid.setSpacing(1, 1)
+ self.view3d.addItem(grid)
+
+ axis = gl.GLAxisItem()
+ axis.setSize(2, 2, 2)
+ self.view3d.addItem(axis)
+
+ verts, faces = make_cuboid()
+ colors = np.ones((faces.shape[0], 4), dtype=float)
+ colors[:,0]=0.25; colors[:,1]=0.7; colors[:,2]=0.35; colors[:,3]=0.9
+
+ meshdata = gl.MeshData(vertexes=verts, faces=faces)
+ self.mesh = gl.GLMeshItem(meshdata=meshdata, faceColors=colors, drawEdges=True, edgeColor=(0,0,0,1))
+ self.view3d.addItem(self.mesh)
+
+ self.vec = gl.GLLinePlotItem(pos=np.array([[0,0,0],[0,0,1]]), width=3, antialias=True)
+ self.view3d.addItem(self.vec)
+
+ # Small overlay label (top-left of window)
+ self.label = QtWidgets.QLabel()
+ self.label.setStyleSheet("color:white; background:rgba(0,0,0,140); padding:6px;")
+ vbox.addWidget(self.label)
+
+ # ---- Graph ----
+ self.plot = pg.PlotWidget()
+ self.plot.setMinimumHeight(200)
+ self.plot.showGrid(x=True, y=True, alpha=0.25)
+ self.plot.setLabel("left", "Acceleration", units="g")
+ self.plot.setLabel("bottom", "Time", units="s")
+ self.plot.setYRange(-MAX_G, MAX_G)
+ self.plot.addLegend(offset=(10, 10))
+ vbox.addWidget(self.plot, stretch=1)
+
+ # Curves
+ self.curve_ax = self.plot.plot([], [], name="ax", pen=pg.mkPen('r', width=2))
+ self.curve_ay = self.plot.plot([], [], name="ay", pen=pg.mkPen('g', width=2))
+ self.curve_az = self.plot.plot([], [], name="az", pen=pg.mkPen('b', width=2))
+
+ # ---- State ----
+ self.roll = 0.0
+ self.pitch = 0.0
+ self.t0 = time.time()
+
+ # ---- Timers ----
+ self.timer = QtCore.QTimer()
+ self.timer.timeout.connect(self.update_ui)
+ self.timer.start(GRAPH_UPDATE_MS)
+
+ def update_ui(self):
+ axg, ayg, azg = latest["ax"], latest["ay"], latest["az"]
+
+ # Add to history buffers
+ t = time.time() - self.t0
+ t_buf.append(t)
+ ax_buf.append(axg)
+ ay_buf.append(ayg)
+ az_buf.append(azg)
+
+ # Trim buffers to last HISTORY_SECONDS
+ while t_buf and (t - t_buf[0]) > HISTORY_SECONDS:
+ t_buf.pop(0)
+ ax_buf.pop(0)
+ ay_buf.pop(0)
+ az_buf.pop(0)
+
+ # Update plot curves
+ self.curve_ax.setData(t_buf, ax_buf)
+ self.curve_ay.setData(t_buf, ay_buf)
+ self.curve_az.setData(t_buf, az_buf)
+ if t_buf:
+ self.plot.setXRange(max(0, t_buf[-1] - HISTORY_SECONDS), t_buf[-1])
+
+ # Update 3D block tilt (smoothed)
+ roll, pitch = roll_pitch_from_accel(axg, ayg, azg)
+ alpha = 0.15
+ self.roll = (1 - alpha) * self.roll + alpha * roll
+ self.pitch = (1 - alpha) * self.pitch + alpha * pitch
+
+ self.mesh.resetTransform()
+ self.mesh.rotate(self.pitch, 0, 1, 0)
+ self.mesh.rotate(self.roll, 1, 0, 0)
+
+ # Update accel vector
+ self.vec.setData(pos=np.array([[0, 0, 0], [axg, ayg, azg]], dtype=float))
+
+ # Update label
+ age = (time.time() - latest["ts"]) * 1000 if latest["ts"] else 0
+ self.label.setText(
+ f"Packets: {latest['count']} Age: {age:.0f} ms\n"
+ f"ax={axg:+.3f}g ay={ayg:+.3f}g az={azg:+.3f}g\n"
+ f"roll={self.roll:+.1f}° pitch={self.pitch:+.1f}°"
+ )
+
+def main():
+ print("IMPORTANT: Disconnect nRF Connect (or any other BLE client) first.")
+ start_ble_thread()
+
+ app = QtWidgets.QApplication.instance()
+ if app is None:
+ app = QtWidgets.QApplication(sys.argv)
+
+ win = MainWindow()
+ win.resize(1000, 750)
+ win.show()
+ sys.exit(app.exec_())
+
+if __name__ == "__main__":
+ main()
diff --git a/_Sort/ble/V006.py b/_Sort/ble/V006.py
new file mode 100644
index 0000000..ebfcd36
--- /dev/null
+++ b/_Sort/ble/V006.py
@@ -0,0 +1,331 @@
+# V005.py (VERSION: 3D-PCB+GRAPH+SHAKEBAR-1)
+print("=== V006 VERSION: 3D-PCB+GRAPH+SHAKEBAR-1 ===")
+
+import sys
+import time
+import math
+import asyncio
+import threading
+
+import numpy as np
+from bleak import BleakClient
+
+from PyQt5 import QtWidgets, QtCore
+import pyqtgraph as pg
+import pyqtgraph.opengl as gl
+
+# ====== HARD-CODED DEVICE ======
+ADDRESS = "10:51:DB:1B:E7:1E"
+CHAR_UUID = "7e2a1002-1111-2222-3333-444455556666"
+
+# ====== GRAPH SETTINGS ======
+HISTORY_SECONDS = 10.0
+UI_UPDATE_MS = 50
+MAX_G = 4.0
+
+# ====== SHAKE METRICS SETTINGS ======
+# magnitude |a| in g (gravity ~1.0g when stationary)
+WARN_MAG_G = 1.30 # mild motion
+SHAKE_MAG_G = 1.70 # strong shake
+
+# Use delta from 1g for percent mapping:
+# delta_g = abs(|a| - 1.0)
+DELTA_G_FULL_SCALE = 1.0 # delta=1.0g => 100%
+
+# Shared latest values (written by BLE notify, read by UI)
+latest = {"ax": 0.0, "ay": 0.0, "az": 1.0, "ts": 0.0, "count": 0, "raw": ""}
+
+# Ring buffers for plotting
+t_buf = []
+ax_buf = []
+ay_buf = []
+az_buf = []
+mag_buf = []
+
+# ---------------- BLE ----------------
+
+def parse_csv_triplet(s: str):
+ s = s.strip().strip('"')
+ parts = s.split(",")
+ if len(parts) != 3:
+ return None
+ try:
+ return float(parts[0]), float(parts[1]), float(parts[2])
+ except ValueError:
+ return None
+
+def notify_handler(_sender: int, data: bytearray):
+ s = data.decode(errors="ignore").strip()
+ latest["raw"] = s
+ v = parse_csv_triplet(s)
+ if v is None:
+ return
+ latest["ax"], latest["ay"], latest["az"] = v
+ latest["ts"] = time.time()
+ latest["count"] += 1
+
+def roll_pitch_from_accel(ax, ay, az):
+ roll = math.degrees(math.atan2(ay, az))
+ pitch = math.degrees(math.atan2(-ax, math.sqrt(ay * ay + az * az)))
+ return roll, pitch
+
+async def ble_loop():
+ while True:
+ try:
+ print(f"Connecting to {ADDRESS} ...")
+ async with BleakClient(ADDRESS, timeout=15.0) as client:
+ if not client.is_connected:
+ raise RuntimeError("Connect failed.")
+ print("Connected. Enabling notifications...")
+ await client.start_notify(CHAR_UUID, notify_handler)
+ print("Notify enabled. Streaming...\n")
+ while True:
+ await asyncio.sleep(1.0)
+ except Exception as e:
+ print(f"[BLE] Error/disconnect: {e}")
+ print("Reconnecting in 2 seconds...\n")
+ await asyncio.sleep(2.0)
+
+def start_ble_thread():
+ t = threading.Thread(target=lambda: asyncio.run(ble_loop()), daemon=True)
+ t.start()
+
+# ---------------- 3D helpers ----------------
+
+def make_cuboid(size=(2.0, 1.2, 0.1)):
+ L, W, T = size
+ x, y, z = L/2, W/2, T/2
+ verts = np.array([
+ [-x,-y,-z], [ x,-y,-z], [ x, y,-z], [-x, y,-z],
+ [-x,-y, z], [ x,-y, z], [ x, y, z], [-x, y, z],
+ ], dtype=float)
+ faces = np.array([
+ [0,1,2],[0,2,3],
+ [4,6,5],[4,7,6],
+ [0,4,5],[0,5,1],
+ [1,5,6],[1,6,2],
+ [2,6,7],[2,7,3],
+ [3,7,4],[3,4,0],
+ ], dtype=int)
+ return verts, faces
+
+# ---------------- UI ----------------
+
+class MainWindow(QtWidgets.QMainWindow):
+ def __init__(self):
+ super().__init__()
+ self.setWindowTitle("ADXL345 – 3D PCB + Live Graph + Shake Meter (BLE)")
+
+ central = QtWidgets.QWidget()
+ self.setCentralWidget(central)
+ outer = QtWidgets.QVBoxLayout(central)
+ outer.setContentsMargins(6, 6, 6, 6)
+ outer.setSpacing(6)
+
+ # ---- 3D view ----
+ self.view3d = gl.GLViewWidget()
+ self.view3d.setMinimumHeight(420)
+ self.view3d.setCameraPosition(distance=6, elevation=25, azimuth=40)
+ outer.addWidget(self.view3d, stretch=3)
+
+ grid = gl.GLGridItem()
+ grid.setSize(10, 10)
+ grid.setSpacing(1, 1)
+ self.view3d.addItem(grid)
+
+ axis = gl.GLAxisItem()
+ axis.setSize(2, 2, 2)
+ self.view3d.addItem(axis)
+
+ verts, faces = make_cuboid()
+ colors = np.ones((faces.shape[0], 4), dtype=float)
+ colors[:,0]=0.25; colors[:,1]=0.7; colors[:,2]=0.35; colors[:,3]=0.9
+
+ meshdata = gl.MeshData(vertexes=verts, faces=faces)
+ self.mesh = gl.GLMeshItem(meshdata=meshdata, faceColors=colors,
+ drawEdges=True, edgeColor=(0,0,0,1))
+ self.view3d.addItem(self.mesh)
+
+ self.vec = gl.GLLinePlotItem(pos=np.array([[0,0,0],[0,0,1]]),
+ width=3, antialias=True)
+ self.view3d.addItem(self.vec)
+
+ # ---- Status label ----
+ self.status = QtWidgets.QLabel()
+ self.status.setStyleSheet("color:white; background:rgba(0,0,0,140); padding:6px;")
+ outer.addWidget(self.status)
+
+ # ---- Bottom area: graph + shake meter (right) ----
+ bottom = QtWidgets.QHBoxLayout()
+ bottom.setSpacing(10)
+ outer.addLayout(bottom, stretch=2)
+
+ # Graph
+ self.plot = pg.PlotWidget()
+ self.plot.setMinimumHeight(230)
+ self.plot.showGrid(x=True, y=True, alpha=0.25)
+ self.plot.setLabel("left", "Acceleration", units="g")
+ self.plot.setLabel("bottom", "Time", units="s")
+ self.plot.setYRange(-MAX_G, MAX_G)
+ self.plot.addLegend(offset=(10, 10))
+
+ bottom.addWidget(self.plot, stretch=5)
+
+ # Curves
+ self.curve_ax = self.plot.plot([], [], name="ax", pen=pg.mkPen('r', width=2))
+ self.curve_ay = self.plot.plot([], [], name="ay", pen=pg.mkPen('g', width=2))
+ self.curve_az = self.plot.plot([], [], name="az", pen=pg.mkPen('b', width=2))
+ self.curve_mag = self.plot.plot([], [], name="|a|", pen=pg.mkPen('y', width=2))
+
+ # Threshold lines (horizontal) for magnitude
+ self.warn_line = pg.InfiniteLine(pos=+WARN_MAG_G, angle=0, pen=pg.mkPen((255,165,0), width=2, style=QtCore.Qt.DashLine))
+ self.shake_line = pg.InfiniteLine(pos=+SHAKE_MAG_G, angle=0, pen=pg.mkPen((255, 60, 60), width=2, style=QtCore.Qt.DashLine))
+ self.plot.addItem(self.warn_line)
+ self.plot.addItem(self.shake_line)
+
+ # Shake meter panel (right)
+ panel = QtWidgets.QVBoxLayout()
+ panel.setSpacing(6)
+ bottom.addLayout(panel, stretch=1)
+
+ self.meter_title = QtWidgets.QLabel("Shake magnitude")
+ self.meter_title.setStyleSheet("font-weight: 600;")
+ panel.addWidget(self.meter_title)
+
+ self.meter_bar = QtWidgets.QProgressBar()
+ self.meter_bar.setRange(0, 100)
+ self.meter_bar.setValue(0)
+ self.meter_bar.setFormat("%p%")
+ self.meter_bar.setTextVisible(True)
+ self.meter_bar.setMinimumWidth(220)
+ self.meter_bar.setMinimumHeight(28)
+ panel.addWidget(self.meter_bar)
+
+ self.meter_readout = QtWidgets.QLabel("|a| = 0.000 g\nΔ=0.000 g")
+ panel.addWidget(self.meter_readout)
+
+ self.indicators = QtWidgets.QLabel("CALM")
+ self.indicators.setAlignment(QtCore.Qt.AlignCenter)
+ self.indicators.setStyleSheet(
+ "font-weight: 700; font-size: 18px; padding: 10px; "
+ "border: 2px solid #555; border-radius: 10px;"
+ )
+ panel.addWidget(self.indicators)
+
+ panel.addStretch(1)
+
+ # ---- State ----
+ self.roll = 0.0
+ self.pitch = 0.0
+ self.t0 = time.time()
+
+ # ---- Timer ----
+ self.timer = QtCore.QTimer()
+ self.timer.timeout.connect(self.update_ui)
+ self.timer.start(UI_UPDATE_MS)
+
+ def set_indicator_state(self, state: str):
+ # Simple color changes via stylesheet
+ if state == "CALM":
+ self.indicators.setText("CALM")
+ self.indicators.setStyleSheet(
+ "font-weight: 700; font-size: 18px; padding: 10px;"
+ "border: 2px solid #555; border-radius: 10px;"
+ "background: rgba(80,80,80,120); color: white;"
+ )
+ elif state == "WARN":
+ self.indicators.setText("WARN")
+ self.indicators.setStyleSheet(
+ "font-weight: 700; font-size: 18px; padding: 10px;"
+ "border: 2px solid #a86a00; border-radius: 10px;"
+ "background: rgba(255,165,0,130); color: black;"
+ )
+ else: # SHAKE
+ self.indicators.setText("SHAKE!")
+ self.indicators.setStyleSheet(
+ "font-weight: 800; font-size: 20px; padding: 10px;"
+ "border: 2px solid #b00000; border-radius: 10px;"
+ "background: rgba(255,60,60,180); color: white;"
+ )
+
+ def update_ui(self):
+ axg, ayg, azg = latest["ax"], latest["ay"], latest["az"]
+
+ # Magnitude (g)
+ mag = math.sqrt(axg*axg + ayg*ayg + azg*azg)
+ delta = abs(mag - 1.0)
+
+ # Map delta to 0..100%
+ pct = int(max(0.0, min(1.0, delta / max(1e-6, DELTA_G_FULL_SCALE))) * 100.0)
+ self.meter_bar.setValue(pct)
+ self.meter_readout.setText(f"|a| = {mag:.3f} g\nΔ = {delta:.3f} g")
+
+ # Threshold indicators
+ if mag >= SHAKE_MAG_G:
+ self.set_indicator_state("SHAKE")
+ elif mag >= WARN_MAG_G:
+ self.set_indicator_state("WARN")
+ else:
+ self.set_indicator_state("CALM")
+
+ # Add to history buffers
+ t = time.time() - self.t0
+ t_buf.append(t)
+ ax_buf.append(axg)
+ ay_buf.append(ayg)
+ az_buf.append(azg)
+ mag_buf.append(mag)
+
+ # Trim buffers
+ while t_buf and (t - t_buf[0]) > HISTORY_SECONDS:
+ t_buf.pop(0)
+ ax_buf.pop(0)
+ ay_buf.pop(0)
+ az_buf.pop(0)
+ mag_buf.pop(0)
+
+ # Update plot
+ self.curve_ax.setData(t_buf, ax_buf)
+ self.curve_ay.setData(t_buf, ay_buf)
+ self.curve_az.setData(t_buf, az_buf)
+ self.curve_mag.setData(t_buf, mag_buf)
+
+ if t_buf:
+ self.plot.setXRange(max(0, t_buf[-1] - HISTORY_SECONDS), t_buf[-1])
+
+ # Update 3D tilt (smoothed)
+ roll, pitch = roll_pitch_from_accel(axg, ayg, azg)
+ alpha = 0.15
+ self.roll = (1 - alpha) * self.roll + alpha * roll
+ self.pitch = (1 - alpha) * self.pitch + alpha * pitch
+
+ self.mesh.resetTransform()
+ self.mesh.rotate(self.pitch, 0, 1, 0)
+ self.mesh.rotate(self.roll, 1, 0, 0)
+
+ # Vector line
+ self.vec.setData(pos=np.array([[0, 0, 0], [axg, ayg, azg]], dtype=float))
+
+ # Top status text
+ age = (time.time() - latest["ts"]) * 1000 if latest["ts"] else 0
+ self.status.setText(
+ f"Packets: {latest['count']} Age: {age:.0f} ms\n"
+ f"ax={axg:+.3f}g ay={ayg:+.3f}g az={azg:+.3f}g |a|={mag:.3f}g\n"
+ f"roll={self.roll:+.1f}° pitch={self.pitch:+.1f}°"
+ )
+
+def main():
+ print("IMPORTANT: Disconnect nRF Connect (or any other BLE client) first.")
+ start_ble_thread()
+
+ app = QtWidgets.QApplication.instance()
+ if app is None:
+ app = QtWidgets.QApplication(sys.argv)
+
+ win = MainWindow()
+ win.resize(1100, 820)
+ win.show()
+ sys.exit(app.exec_())
+
+if __name__ == "__main__":
+ main()
diff --git a/_Sort/ble/V007.py b/_Sort/ble/V007.py
new file mode 100644
index 0000000..6c125e9
--- /dev/null
+++ b/_Sort/ble/V007.py
@@ -0,0 +1,295 @@
+# bme680_ui.py (VERSION: BME680-GRAPH+BAR-1)
+print("=== BME680 UI VERSION: BME680-GRAPH+BAR-1 ===")
+
+import asyncio
+import threading
+import time
+import math
+import sys
+
+from bleak import BleakClient
+from PyQt5 import QtWidgets, QtCore
+import pyqtgraph as pg
+
+# ====== HARD-CODED DEVICE + UUIDs ======
+ADDRESS = "98:88:E0:76:30:56" # change if your BME680 device uses a different MAC
+CHAR_UUID = "7e2a0002-1111-2222-3333-444455556666" # change if different from ADXL project
+
+# ====== UI SETTINGS ======
+HISTORY_SECONDS = 120.0 # 2 minutes of history (BME changes slower than accel)
+UI_UPDATE_MS = 250 # 4 Hz UI refresh is plenty for env data
+
+# “Air change” percent meter tuning (based on gas resistance change)
+# We measure delta from a slowly-updated baseline.
+BASELINE_ALPHA = 0.01 # slower = steadier baseline
+DELTA_FULL_SCALE = 20000 # ohms delta => 100% (tune this)
+
+# Thresholds for indicator states (percent)
+WARN_PCT = 30
+ALERT_PCT = 60
+
+latest = {
+ "t": None, # °C
+ "h": None, # %
+ "gas": None, # ohms
+ "p": None, # hPa
+ "alt": None, # m
+ "ts": 0.0,
+ "count": 0,
+ "raw": "",
+}
+
+# Buffers
+t_buf = []
+temp_buf = []
+hum_buf = []
+press_buf = []
+gas_buf = []
+alt_buf = []
+
+gas_baseline = None # running baseline for “change” meter
+
+
+def parse_csv_5(s: str):
+ s = s.strip().strip('"')
+ parts = s.split(",")
+ if len(parts) != 5:
+ return None
+ try:
+ # temp, hum, gas_ohms, pressure_hpa, altitude_m
+ return float(parts[0]), float(parts[1]), float(parts[2]), float(parts[3]), float(parts[4])
+ except ValueError:
+ return None
+
+
+def notify_handler(_sender: int, data: bytearray):
+ s = data.decode(errors="ignore").strip()
+ latest["raw"] = s
+ v = parse_csv_5(s)
+ if v is None:
+ return
+
+ latest["t"], latest["h"], latest["gas"], latest["p"], latest["alt"] = v
+ latest["ts"] = time.time()
+ latest["count"] += 1
+
+
+async def ble_loop():
+ while True:
+ try:
+ print(f"Connecting to {ADDRESS} ...")
+ async with BleakClient(ADDRESS, timeout=15.0) as client:
+ if not client.is_connected:
+ raise RuntimeError("Connect failed.")
+
+ print("Connected. Enabling notifications...")
+ await client.start_notify(CHAR_UUID, notify_handler)
+ print("Notify enabled. Streaming...\n")
+
+ while True:
+ await asyncio.sleep(1.0)
+
+ except Exception as e:
+ print(f"[BLE] Error/disconnect: {e}")
+ print("Reconnecting in 2 seconds...\n")
+ await asyncio.sleep(2.0)
+
+
+def start_ble_thread():
+ t = threading.Thread(target=lambda: asyncio.run(ble_loop()), daemon=True)
+ t.start()
+
+
+class MainWindow(QtWidgets.QMainWindow):
+ def __init__(self):
+ super().__init__()
+ self.setWindowTitle("BME680 – Live Graph + Air-Change Meter (BLE)")
+
+ central = QtWidgets.QWidget()
+ self.setCentralWidget(central)
+
+ outer = QtWidgets.QVBoxLayout(central)
+ outer.setContentsMargins(8, 8, 8, 8)
+ outer.setSpacing(8)
+
+ self.status = QtWidgets.QLabel("Waiting for data...")
+ self.status.setStyleSheet("color:white; background:rgba(0,0,0,140); padding:8px;")
+ outer.addWidget(self.status)
+
+ # Bottom area: plots + meter on right
+ row = QtWidgets.QHBoxLayout()
+ row.setSpacing(10)
+ outer.addLayout(row)
+
+ # One plot with multiple y-scales is messy; we’ll use 2 plots stacked.
+ plots_col = QtWidgets.QVBoxLayout()
+ plots_col.setSpacing(8)
+ row.addLayout(plots_col, stretch=5)
+
+ # Plot 1: Temp + Humidity
+ self.plot1 = pg.PlotWidget()
+ self.plot1.showGrid(x=True, y=True, alpha=0.25)
+ self.plot1.setLabel("left", "Temp (°C) / Humidity (%)")
+ self.plot1.setLabel("bottom", "Time (s)")
+ self.plot1.addLegend(offset=(10, 10))
+ plots_col.addWidget(self.plot1)
+
+ self.curve_temp = self.plot1.plot([], [], name="Temp °C", pen=pg.mkPen('r', width=2))
+ self.curve_hum = self.plot1.plot([], [], name="Humidity %", pen=pg.mkPen('g', width=2))
+
+ # Plot 2: Pressure + Gas (gas is big so it’ll dominate visually; that’s ok)
+ self.plot2 = pg.PlotWidget()
+ self.plot2.showGrid(x=True, y=True, alpha=0.25)
+ self.plot2.setLabel("left", "Pressure (hPa) / Gas (Ω)")
+ self.plot2.setLabel("bottom", "Time (s)")
+ self.plot2.addLegend(offset=(10, 10))
+ plots_col.addWidget(self.plot2)
+
+ self.curve_press = self.plot2.plot([], [], name="Pressure hPa", pen=pg.mkPen('c', width=2))
+ self.curve_gas = self.plot2.plot([], [], name="Gas Ω", pen=pg.mkPen('y', width=2))
+
+ # Meter panel on right
+ panel = QtWidgets.QVBoxLayout()
+ panel.setSpacing(8)
+ row.addLayout(panel, stretch=1)
+
+ title = QtWidgets.QLabel("Air change (gas Δ)")
+ title.setStyleSheet("font-weight: 700;")
+ panel.addWidget(title)
+
+ self.bar = QtWidgets.QProgressBar()
+ self.bar.setRange(0, 100)
+ self.bar.setValue(0)
+ self.bar.setMinimumWidth(240)
+ self.bar.setMinimumHeight(28)
+ self.bar.setFormat("%p%")
+ panel.addWidget(self.bar)
+
+ self.readout = QtWidgets.QLabel("gas: --- Ω\nbaseline: --- Ω\nΔ: --- Ω")
+ panel.addWidget(self.readout)
+
+ self.ind = QtWidgets.QLabel("CALM")
+ self.ind.setAlignment(QtCore.Qt.AlignCenter)
+ self.ind.setStyleSheet(
+ "font-weight: 800; font-size: 20px; padding: 10px;"
+ "border: 2px solid #555; border-radius: 10px;"
+ "background: rgba(80,80,80,120); color: white;"
+ )
+ panel.addWidget(self.ind)
+ panel.addStretch(1)
+
+ self.t0 = time.time()
+
+ self.timer = QtCore.QTimer()
+ self.timer.timeout.connect(self.update_ui)
+ self.timer.start(UI_UPDATE_MS)
+
+ def set_state(self, state: str):
+ if state == "CALM":
+ self.ind.setText("CALM")
+ self.ind.setStyleSheet(
+ "font-weight: 800; font-size: 20px; padding: 10px;"
+ "border: 2px solid #555; border-radius: 10px;"
+ "background: rgba(80,80,80,120); color: white;"
+ )
+ elif state == "WARN":
+ self.ind.setText("CHANGE")
+ self.ind.setStyleSheet(
+ "font-weight: 800; font-size: 20px; padding: 10px;"
+ "border: 2px solid #a86a00; border-radius: 10px;"
+ "background: rgba(255,165,0,140); color: black;"
+ )
+ else:
+ self.ind.setText("BIG CHANGE")
+ self.ind.setStyleSheet(
+ "font-weight: 900; font-size: 20px; padding: 10px;"
+ "border: 2px solid #b00000; border-radius: 10px;"
+ "background: rgba(255,60,60,180); color: white;"
+ )
+
+ def update_ui(self):
+ global gas_baseline
+
+ if latest["t"] is None:
+ return
+
+ now = time.time()
+ t = now - self.t0
+
+ temp = latest["t"]
+ hum = latest["h"]
+ gas = latest["gas"]
+ pres = latest["p"]
+ alt = latest["alt"]
+
+ # Update baseline slowly
+ if gas_baseline is None:
+ gas_baseline = gas
+ else:
+ gas_baseline = (1.0 - BASELINE_ALPHA) * gas_baseline + BASELINE_ALPHA * gas
+
+ delta = abs(gas - gas_baseline)
+ pct = int(max(0.0, min(1.0, delta / max(1e-6, DELTA_FULL_SCALE))) * 100.0)
+ self.bar.setValue(pct)
+
+ if pct >= ALERT_PCT:
+ self.set_state("ALERT")
+ elif pct >= WARN_PCT:
+ self.set_state("WARN")
+ else:
+ self.set_state("CALM")
+
+ self.readout.setText(
+ f"gas: {gas:,.0f} Ω\nbaseline: {gas_baseline:,.0f} Ω\nΔ: {delta:,.0f} Ω"
+ )
+
+ # Buffers
+ t_buf.append(t)
+ temp_buf.append(temp)
+ hum_buf.append(hum)
+ press_buf.append(pres)
+ gas_buf.append(gas)
+
+ # Trim
+ while t_buf and (t - t_buf[0]) > HISTORY_SECONDS:
+ t_buf.pop(0)
+ temp_buf.pop(0)
+ hum_buf.pop(0)
+ press_buf.pop(0)
+ gas_buf.pop(0)
+
+ # Update plots
+ self.curve_temp.setData(t_buf, temp_buf)
+ self.curve_hum.setData(t_buf, hum_buf)
+ self.curve_press.setData(t_buf, press_buf)
+ self.curve_gas.setData(t_buf, gas_buf)
+
+ if t_buf:
+ xmin = max(0, t_buf[-1] - HISTORY_SECONDS)
+ xmax = t_buf[-1]
+ self.plot1.setXRange(xmin, xmax)
+ self.plot2.setXRange(xmin, xmax)
+
+ age_ms = (now - latest["ts"]) * 1000.0 if latest["ts"] else 0.0
+ self.status.setText(
+ f"Packets: {latest['count']} Age: {age_ms:.0f} ms\n"
+ f"T={temp:.2f} °C RH={hum:.1f}% P={pres:.1f} hPa Gas={gas:,.0f} Ω Alt={alt:.1f} m"
+ )
+
+
+def main():
+ print("IMPORTANT: Disconnect nRF Connect (or any other BLE client) first.")
+ start_ble_thread()
+
+ app = QtWidgets.QApplication.instance()
+ if app is None:
+ app = QtWidgets.QApplication(sys.argv)
+
+ win = MainWindow()
+ win.resize(1200, 720)
+ win.show()
+ sys.exit(app.exec_())
+
+
+if __name__ == "__main__":
+ main()
diff --git a/_Sort/bme680-pure-mp-main.zip b/_Sort/bme680-pure-mp-main.zip
new file mode 100644
index 0000000..bcdae7c
Binary files /dev/null and b/_Sort/bme680-pure-mp-main.zip differ
+
+
+
+ Humedad
+ + + +
+
+
+
+ Temperatura
+ + + +
+
+
+
+