mirror of
https://github.com/maziggy/bambuddy.git
synced 2026-10-03 12:46:49 +02:00
300 lines
11 KiB
Python
300 lines
11 KiB
Python
"""Manager for smart plug automation and delayed turn-off."""
|
|
|
|
import asyncio
|
|
import logging
|
|
from datetime import datetime
|
|
from typing import TYPE_CHECKING
|
|
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy import select
|
|
|
|
from backend.app.services.tasmota import tasmota_service
|
|
from backend.app.services.printer_manager import printer_manager
|
|
|
|
if TYPE_CHECKING:
|
|
from backend.app.models.smart_plug import SmartPlug
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class SmartPlugManager:
|
|
"""Manages smart plug automation and delayed turn-off."""
|
|
|
|
def __init__(self):
|
|
self._pending_off: dict[int, asyncio.Task] = {} # plug_id -> task
|
|
self._loop: asyncio.AbstractEventLoop | None = None
|
|
|
|
def set_event_loop(self, loop: asyncio.AbstractEventLoop):
|
|
"""Set the event loop for async operations."""
|
|
self._loop = loop
|
|
|
|
async def _get_plug_for_printer(
|
|
self, printer_id: int, db: AsyncSession
|
|
) -> "SmartPlug | None":
|
|
"""Get the smart plug linked to a printer."""
|
|
from backend.app.models.smart_plug import SmartPlug
|
|
|
|
result = await db.execute(
|
|
select(SmartPlug).where(SmartPlug.printer_id == printer_id)
|
|
)
|
|
return result.scalar_one_or_none()
|
|
|
|
async def on_print_start(self, printer_id: int, db: AsyncSession):
|
|
"""Called when a print starts - turn on plug if configured."""
|
|
plug = await self._get_plug_for_printer(printer_id, db)
|
|
|
|
if not plug:
|
|
return
|
|
|
|
if not plug.enabled:
|
|
logger.debug(f"Smart plug '{plug.name}' is disabled, skipping auto-on")
|
|
return
|
|
|
|
if not plug.auto_on:
|
|
logger.debug(f"Smart plug '{plug.name}' auto_on is disabled")
|
|
return
|
|
|
|
# Cancel any pending off task
|
|
self._cancel_pending_off(plug.id)
|
|
|
|
# Turn on the plug
|
|
logger.info(f"Print started on printer {printer_id}, turning on plug '{plug.name}'")
|
|
success = await tasmota_service.turn_on(plug)
|
|
|
|
if success:
|
|
# Update last state and reset auto_off_executed
|
|
plug.last_state = "ON"
|
|
plug.last_checked = datetime.utcnow()
|
|
plug.auto_off_executed = False # Reset flag when turning on
|
|
await db.commit()
|
|
|
|
async def on_print_complete(
|
|
self, printer_id: int, status: str, db: AsyncSession
|
|
):
|
|
"""Called when a print completes - schedule turn off if configured.
|
|
|
|
Only triggers auto-off on successful completion (status='completed').
|
|
Failed prints keep the printer powered on for user investigation.
|
|
"""
|
|
plug = await self._get_plug_for_printer(printer_id, db)
|
|
|
|
if not plug:
|
|
return
|
|
|
|
if not plug.enabled:
|
|
logger.debug(f"Smart plug '{plug.name}' is disabled, skipping auto-off")
|
|
return
|
|
|
|
if not plug.auto_off:
|
|
logger.debug(f"Smart plug '{plug.name}' auto_off is disabled")
|
|
return
|
|
|
|
# Only auto-off on successful completion, not on failures
|
|
# This allows the user to investigate errors before power-off
|
|
if status != "completed":
|
|
logger.info(
|
|
f"Print on printer {printer_id} ended with status '{status}', "
|
|
f"skipping auto-off for plug '{plug.name}' to allow investigation"
|
|
)
|
|
return
|
|
|
|
logger.info(
|
|
f"Print completed successfully on printer {printer_id}, "
|
|
f"scheduling turn-off for plug '{plug.name}'"
|
|
)
|
|
|
|
if plug.off_delay_mode == "time":
|
|
self._schedule_delayed_off(plug, printer_id, plug.off_delay_minutes * 60)
|
|
elif plug.off_delay_mode == "temperature":
|
|
self._schedule_temp_based_off(plug, printer_id, plug.off_temp_threshold)
|
|
|
|
def _schedule_delayed_off(self, plug: "SmartPlug", printer_id: int, delay_seconds: int):
|
|
"""Schedule turn-off after delay."""
|
|
# Cancel any existing task for this plug
|
|
self._cancel_pending_off(plug.id)
|
|
|
|
logger.info(
|
|
f"Scheduling turn-off for plug '{plug.name}' in {delay_seconds} seconds"
|
|
)
|
|
|
|
task = asyncio.create_task(
|
|
self._delayed_off(plug.id, plug.ip_address, plug.username, plug.password, printer_id, delay_seconds)
|
|
)
|
|
self._pending_off[plug.id] = task
|
|
|
|
async def _delayed_off(
|
|
self,
|
|
plug_id: int,
|
|
ip_address: str,
|
|
username: str | None,
|
|
password: str | None,
|
|
printer_id: int,
|
|
delay_seconds: int,
|
|
):
|
|
"""Wait and turn off."""
|
|
try:
|
|
await asyncio.sleep(delay_seconds)
|
|
|
|
# Create a minimal plug-like object for the tasmota service
|
|
class PlugInfo:
|
|
def __init__(self):
|
|
self.ip_address = ip_address
|
|
self.username = username
|
|
self.password = password
|
|
self.name = f"plug_{plug_id}"
|
|
|
|
plug_info = PlugInfo()
|
|
success = await tasmota_service.turn_off(plug_info)
|
|
logger.info(f"Turned off plug {plug_id} after time delay")
|
|
|
|
# Mark auto_off_executed in database and update printer status
|
|
if success:
|
|
await self._mark_auto_off_executed(plug_id)
|
|
# Mark the printer as offline immediately
|
|
printer_manager.mark_printer_offline(printer_id)
|
|
|
|
except asyncio.CancelledError:
|
|
logger.debug(f"Delayed turn-off cancelled for plug {plug_id}")
|
|
finally:
|
|
self._pending_off.pop(plug_id, None)
|
|
|
|
def _schedule_temp_based_off(
|
|
self, plug: "SmartPlug", printer_id: int, temp_threshold: int
|
|
):
|
|
"""Monitor temperature and turn off when below threshold."""
|
|
# Cancel any existing task for this plug
|
|
self._cancel_pending_off(plug.id)
|
|
|
|
logger.info(
|
|
f"Scheduling temperature-based turn-off for plug '{plug.name}' "
|
|
f"(threshold: {temp_threshold}°C)"
|
|
)
|
|
|
|
task = asyncio.create_task(
|
|
self._temp_based_off(
|
|
plug.id,
|
|
plug.ip_address,
|
|
plug.username,
|
|
plug.password,
|
|
printer_id,
|
|
temp_threshold,
|
|
)
|
|
)
|
|
self._pending_off[plug.id] = task
|
|
|
|
async def _temp_based_off(
|
|
self,
|
|
plug_id: int,
|
|
ip_address: str,
|
|
username: str | None,
|
|
password: str | None,
|
|
printer_id: int,
|
|
temp_threshold: int,
|
|
):
|
|
"""Poll temperature until below threshold, then turn off.
|
|
|
|
For dual-extruder printers (H2 series), checks both nozzles.
|
|
"""
|
|
try:
|
|
check_interval = 10 # seconds
|
|
max_wait = 3600 # 1 hour max
|
|
elapsed = 0
|
|
|
|
while elapsed < max_wait:
|
|
status = printer_manager.get_status(printer_id)
|
|
|
|
if status:
|
|
temps = status.temperatures or {}
|
|
nozzle_temp = temps.get("nozzle", 999)
|
|
# Check second nozzle for dual-extruder printers (H2 series)
|
|
nozzle_2_temp = temps.get("nozzle_2")
|
|
|
|
# Get the maximum temperature across all nozzles
|
|
max_nozzle_temp = nozzle_temp
|
|
if nozzle_2_temp is not None:
|
|
max_nozzle_temp = max(nozzle_temp, nozzle_2_temp)
|
|
logger.info(
|
|
f"Temp check plug {plug_id}: nozzle1={nozzle_temp}°C, "
|
|
f"nozzle2={nozzle_2_temp}°C, max={max_nozzle_temp}°C, "
|
|
f"threshold={temp_threshold}°C"
|
|
)
|
|
else:
|
|
logger.info(
|
|
f"Temp check plug {plug_id}: nozzle={nozzle_temp}°C, "
|
|
f"threshold={temp_threshold}°C"
|
|
)
|
|
|
|
if max_nozzle_temp < temp_threshold:
|
|
# All nozzles are below threshold, turn off
|
|
class PlugInfo:
|
|
def __init__(self):
|
|
self.ip_address = ip_address
|
|
self.username = username
|
|
self.password = password
|
|
self.name = f"plug_{plug_id}"
|
|
|
|
plug_info = PlugInfo()
|
|
success = await tasmota_service.turn_off(plug_info)
|
|
logger.info(
|
|
f"Turned off plug {plug_id} after nozzle temp dropped to "
|
|
f"{max_nozzle_temp}°C (threshold: {temp_threshold}°C)"
|
|
)
|
|
|
|
# Mark auto_off_executed in database and update printer status
|
|
if success:
|
|
await self._mark_auto_off_executed(plug_id)
|
|
# Mark the printer as offline immediately
|
|
printer_manager.mark_printer_offline(printer_id)
|
|
|
|
break
|
|
|
|
await asyncio.sleep(check_interval)
|
|
elapsed += check_interval
|
|
|
|
if elapsed >= max_wait:
|
|
logger.warning(
|
|
f"Temperature-based turn-off timed out for plug {plug_id} after {max_wait}s"
|
|
)
|
|
|
|
except asyncio.CancelledError:
|
|
logger.debug(f"Temperature-based turn-off cancelled for plug {plug_id}")
|
|
finally:
|
|
self._pending_off.pop(plug_id, None)
|
|
|
|
async def _mark_auto_off_executed(self, plug_id: int):
|
|
"""Disable auto-off after it was executed (one-shot behavior)."""
|
|
try:
|
|
from backend.app.core.database import async_session
|
|
from backend.app.models.smart_plug import SmartPlug
|
|
|
|
async with async_session() as db:
|
|
result = await db.execute(
|
|
select(SmartPlug).where(SmartPlug.id == plug_id)
|
|
)
|
|
plug = result.scalar_one_or_none()
|
|
if plug:
|
|
plug.auto_off = False # Disable auto-off (one-shot behavior)
|
|
plug.auto_off_executed = False # Reset the flag
|
|
plug.last_state = "OFF"
|
|
plug.last_checked = datetime.utcnow()
|
|
await db.commit()
|
|
logger.info(f"Auto-off executed and disabled for plug {plug_id}")
|
|
except Exception as e:
|
|
logger.warning(f"Failed to update plug {plug_id} after auto-off: {e}")
|
|
|
|
def _cancel_pending_off(self, plug_id: int):
|
|
"""Cancel any pending off task for this plug."""
|
|
if plug_id in self._pending_off:
|
|
logger.debug(f"Cancelling pending turn-off for plug {plug_id}")
|
|
self._pending_off[plug_id].cancel()
|
|
del self._pending_off[plug_id]
|
|
|
|
def cancel_all_pending(self):
|
|
"""Cancel all pending turn-off tasks."""
|
|
for plug_id in list(self._pending_off.keys()):
|
|
self._cancel_pending_off(plug_id)
|
|
|
|
|
|
# Global singleton
|
|
smart_plug_manager = SmartPlugManager()
|