flashforge-python-api 1.0.0__py3-none-any.whl

flashforge/tcp/gcode/gcode_controller.py

@@ -0,0 +1,296 @@
+"""
+G-code controller for FlashForge 3D printers.
+
+This module provides high-level G-code command methods that build upon
+the basic TCP communication provided by FlashForgeTcpClient.
+"""
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+
+from .gcodes import GCodes
+
+if TYPE_CHECKING:
+    from ..ff_client import FlashForgeClient
+
+logger = logging.getLogger(__name__)
+
+
+class GCodeController:
+    """
+    Controller for sending specific G-code commands to FlashForge printers.
+    
+    This class provides convenient methods for common printer operations
+    like LED control, job management, movement, and temperature control.
+    """
+
+    def __init__(self, client: 'FlashForgeClient') -> None:
+        """
+        Initialize the G-code controller.
+        
+        Args:
+            client: The FlashForgeClient instance for sending commands
+        """
+        self.client = client
+
+    async def led_on(self) -> bool:
+        """
+        Turn the printer's LED lights on.
+        
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        return await self.client.send_cmd_ok(GCodes.CMD_LED_ON)
+
+    async def led_off(self) -> bool:
+        """
+        Turn the printer's LED lights off.
+        
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        return await self.client.send_cmd_ok(GCodes.CMD_LED_OFF)
+
+    async def pause_job(self) -> bool:
+        """
+        Pause the current print job.
+        
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        return await self.client.send_cmd_ok(GCodes.CMD_PAUSE_PRINT)
+
+    async def resume_job(self) -> bool:
+        """
+        Resume a paused print job.
+        
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        return await self.client.send_cmd_ok(GCodes.CMD_RESUME_PRINT)
+
+    async def stop_job(self) -> bool:
+        """
+        Stop the current print job.
+        
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        return await self.client.send_cmd_ok(GCodes.CMD_STOP_PRINT)
+
+    async def start_job(self, filename: str) -> bool:
+        """
+        Start a print job from a file stored on the printer.
+        
+        Args:
+            filename: The name of the file to print (typically without path)
+            
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        cmd = GCodes.CMD_START_PRINT.replace("%%filename%%", filename)
+        return await self.client.send_cmd_ok(cmd)
+
+    async def home(self) -> bool:
+        """
+        Home all axes (X, Y, Z) of the printer.
+        
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        return await self.client.send_cmd_ok(GCodes.CMD_HOME_AXES)
+
+    async def rapid_home(self) -> bool:
+        """
+        Perform a rapid homing of all axes.
+        
+        Note: This uses the same command as regular homing in the current implementation.
+        
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        # In the TypeScript implementation, this is the same as home()
+        return await self.home()
+
+    async def move(self, x: float, y: float, z: float, feedrate: int) -> bool:
+        """
+        Move the extruder to a specified X, Y, Z position.
+        
+        Args:
+            x: The target X coordinate
+            y: The target Y coordinate  
+            z: The target Z coordinate
+            feedrate: The feedrate for the movement in mm/min
+            
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        cmd = f"~G1 X{x} Y{y} Z{z} F{feedrate}"
+        return await self.client.send_cmd_ok(cmd)
+
+    async def move_extruder(self, x: float, y: float, feedrate: int) -> bool:
+        """
+        Move the extruder to a specified X, Y position.
+        
+        Args:
+            x: The target X coordinate
+            y: The target Y coordinate
+            feedrate: The feedrate for the movement in mm/min
+            
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        cmd = f"~G1 X{x} Y{y} F{feedrate}"
+        return await self.client.send_cmd_ok(cmd)
+
+    async def extrude(self, length: float, feedrate: int = 450) -> bool:
+        """
+        Command the extruder to extrude a specific length of filament.
+        
+        Args:
+            length: The length of filament to extrude in millimeters
+            feedrate: The feedrate for extrusion in mm/min (default: 450)
+            
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        cmd = f"~G1 E{length} F{feedrate}"
+        return await self.client.send_cmd_ok(cmd)
+
+    async def set_extruder_temp(self, temp: int, wait_for: bool = False) -> bool:
+        """
+        Set the target temperature for the extruder.
+        
+        Args:
+            temp: The target temperature in Celsius
+            wait_for: If True, wait until the target temperature is reached
+            
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        if wait_for:
+            cmd = f"{GCodes.WAIT_FOR_HOTEND_TEMP} S{temp}"
+            ok = await self.client.send_cmd_ok(cmd)
+            if not ok:
+                return False
+            # Wait for temperature to be reached
+            return await self.wait_for_extruder_temp(temp)
+        else:
+            cmd = f"~M104 S{temp}"
+            return await self.client.send_cmd_ok(cmd)
+
+    async def set_bed_temp(self, temp: int, wait_for: bool = False) -> bool:
+        """
+        Set the target temperature for the print bed.
+        
+        Args:
+            temp: The target temperature in Celsius  
+            wait_for: If True, wait until the target temperature is reached
+            
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        if wait_for:
+            cmd = f"{GCodes.WAIT_FOR_BED_TEMP} S{temp}"
+            ok = await self.client.send_cmd_ok(cmd)
+            if not ok:
+                return False
+            # Wait for temperature to be reached
+            return await self.wait_for_bed_temp(temp)
+        else:
+            cmd = f"~M140 S{temp}"
+            return await self.client.send_cmd_ok(cmd)
+
+    async def cancel_extruder_temp(self) -> bool:
+        """
+        Cancel extruder heating and set its target temperature to 0.
+        
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        cmd = "~M104 S0"
+        ok = await self.client.send_cmd_ok(cmd)
+        return ok
+
+    async def cancel_bed_temp(self, wait_for_cool: bool = False) -> bool:
+        """
+        Cancel print bed heating and set its target temperature to 0.
+        
+        Args:
+            wait_for_cool: If True, wait for the bed to cool down after canceling
+            
+        Returns:
+            True if the command was successful, False otherwise
+        """
+        cmd = "~M140 S0"
+        ok = await self.client.send_cmd_ok(cmd)
+        if not ok:
+            return False
+
+        if wait_for_cool:
+            # Wait for bed to cool down to a reasonable temperature
+            return await self.wait_for_bed_temp(40, cooling=True)
+
+        return True
+
+    async def wait_for_bed_temp(self, target_temp: int, cooling: bool = False, timeout: int = 600) -> bool:
+        """
+        Wait for the bed temperature to reach the target.
+        
+        Args:
+            target_temp: The target temperature to wait for
+            cooling: If True, wait for temperature to drop below target; otherwise wait to reach target
+            timeout: Maximum time to wait in seconds (default: 600)
+            
+        Returns:
+            True if target temperature was reached, False on timeout or error
+        """
+        start_time = asyncio.get_event_loop().time()
+        timeout_time = start_time + timeout
+
+        while asyncio.get_event_loop().time() < timeout_time:
+            temp_info = await self.client.get_temp_info()
+            if temp_info:
+                bed_temp = temp_info.get_bed_temp()
+                if bed_temp:
+                    current_temp = bed_temp.get_current()
+                    if cooling:
+                        if current_temp <= target_temp:
+                            return True
+                    else:
+                        if abs(current_temp - target_temp) <= 2:  # Within 2°C tolerance
+                            return True
+
+            await asyncio.sleep(5)  # Check every 5 seconds
+
+        logger.warning(f"Timeout waiting for bed temperature {'cooling to' if cooling else 'heating to'} {target_temp}°C")
+        return False
+
+    async def wait_for_extruder_temp(self, target_temp: int, timeout: int = 600) -> bool:
+        """
+        Wait for the extruder temperature to reach the target.
+        
+        Args:
+            target_temp: The target temperature to wait for
+            timeout: Maximum time to wait in seconds (default: 600)
+            
+        Returns:
+            True if target temperature was reached, False on timeout or error
+        """
+        start_time = asyncio.get_event_loop().time()
+        timeout_time = start_time + timeout
+
+        while asyncio.get_event_loop().time() < timeout_time:
+            temp_info = await self.client.get_temp_info()
+            if temp_info:
+                extruder_temp = temp_info.get_extruder_temp()
+                if extruder_temp:
+                    current_temp = extruder_temp.get_current()
+                    if abs(current_temp - target_temp) <= 2:  # Within 2°C tolerance
+                        return True
+
+            await asyncio.sleep(5)  # Check every 5 seconds
+
+        logger.warning(f"Timeout waiting for extruder temperature to reach {target_temp}°C")
+        return False

flashforge/tcp/gcode/gcodes.py

@@ -0,0 +1,93 @@
+"""
+G-code and M-code command constants for FlashForge 3D printers.
+
+This module defines the standard commands used for TCP communication with FlashForge printers.
+The '~' prefix is characteristic of FlashForge's TCP command protocol.
+Placeholders like '%%filename%%' are intended to be replaced with actual values before sending.
+"""
+
+from typing import Final
+
+
+class GCodes:
+    """
+    Collection of G-code and M-code command strings for FlashForge 3D printers.
+    
+    All commands use the FlashForge TCP protocol with '~' prefix.
+    """
+
+    # Authentication and session control
+    CMD_LOGIN: Final[str] = "~M601 S1"
+    """Command to initiate a control session with the printer (login)."""
+
+    CMD_LOGOUT: Final[str] = "~M602"
+    """Command to terminate a control session with the printer (logout)."""
+
+    # Emergency control
+    CMD_EMERGENCY_STOP: Final[str] = "~M112"
+    """Command for an emergency stop of all printer activity."""
+
+    # Status queries
+    CMD_PRINT_STATUS: Final[str] = "~M27"
+    """Command to request the current print job status."""
+
+    CMD_ENDSTOP_INFO: Final[str] = "~M119"
+    """Command to request the status of the printer's endstops."""
+
+    CMD_INFO_STATUS: Final[str] = "~M115"
+    """Command to request general printer information, including firmware version."""
+
+    CMD_INFO_XYZAB: Final[str] = "~M114"
+    """Command to request the current X, Y, Z, A, B coordinates of the print head."""
+
+    CMD_TEMP: Final[str] = "~M105"
+    """Command to request current temperatures (extruder, bed)."""
+
+    # LED control
+    CMD_LED_ON: Final[str] = "~M146 r255 g255 b255 F0"
+    """Command to turn the printer's LED lights on (full white)."""
+
+    CMD_LED_OFF: Final[str] = "~M146 r0 g0 b0 F0"
+    """Command to turn the printer's LED lights off."""
+
+    # Filament runout sensor
+    CMD_RUNOUT_SENSOR_ON: Final[str] = "~M405"
+    """Command to enable the filament runout sensor."""
+
+    CMD_RUNOUT_SENSOR_OFF: Final[str] = "~M406"
+    """Command to disable the filament runout sensor."""
+
+    # File operations
+    CMD_LIST_LOCAL_FILES: Final[str] = "~M661"
+    """Command to list files stored locally on the printer."""
+
+    CMD_GET_THUMBNAIL: Final[str] = "~M662"
+    """Command to retrieve a thumbnail image for a specified G-code file."""
+
+    # Camera control
+    TAKE_PICTURE: Final[str] = "~M240"
+    """Command to instruct the printer to take a picture with its camera, if equipped."""
+
+    # Movement and homing
+    CMD_HOME_AXES: Final[str] = "~G28"
+    """Command to home all printer axes (X, Y, Z)."""
+
+    # Print job control
+    CMD_START_PRINT: Final[str] = "~M23 0:/user/%%filename%%"
+    """Command to select a file for printing. %%filename%% should be replaced with actual file path."""
+
+    CMD_PAUSE_PRINT: Final[str] = "~M25"
+    """Command to pause the current print job."""
+
+    CMD_RESUME_PRINT: Final[str] = "~M24"
+    """Command to resume a paused print job."""
+
+    CMD_STOP_PRINT: Final[str] = "~M26"
+    """Command to stop/cancel the current print job."""
+
+    # Temperature control with waiting
+    WAIT_FOR_HOTEND_TEMP: Final[str] = "~M109"
+    """Command to set extruder temperature and wait until it's reached. Requires S[temperature] parameter."""
+
+    WAIT_FOR_BED_TEMP: Final[str] = "~M190"
+    """Command to set bed temperature and wait until it's reached. Requires S[temperature] or R[temperature] parameter."""

flashforge/tcp/parsers/__init__.py

@@ -0,0 +1,27 @@
+"""
+Response parsers for FlashForge printer TCP communication.
+
+This module contains classes for parsing various response types from FlashForge printers,
+including printer information, temperature data, location data, and more.
+"""
+
+from .endstop_status import Endstop, EndstopStatus, MachineStatus, MoveMode, Status
+from .location_info import LocationInfo
+from .print_status import PrintStatus
+from .printer_info import PrinterInfo
+from .temp_info import TempData, TempInfo
+from .thumbnail_info import ThumbnailInfo
+
+__all__ = [
+    'PrinterInfo',
+    'TempInfo',
+    'TempData',
+    'LocationInfo',
+    'EndstopStatus',
+    'MachineStatus',
+    'MoveMode',
+    'Status',
+    'Endstop',
+    'PrintStatus',
+    'ThumbnailInfo',
+]

flashforge/tcp/parsers/endstop_status.py

@@ -0,0 +1,273 @@
+"""
+FlashForge Python API - Endstop Status Parser
+
+Parses endstop and machine status information from M119 command responses.
+"""
+import re
+from enum import Enum
+from typing import Optional
+
+
+class MachineStatus(Enum):
+    """Enumerates the possible operational statuses of the machine."""
+    BUILDING_FROM_SD = "BUILDING_FROM_SD"
+    BUILDING_COMPLETED = "BUILDING_COMPLETED"
+    PAUSED = "PAUSED"
+    READY = "READY"
+    BUSY = "BUSY"
+    DEFAULT = "DEFAULT"
+
+
+class MoveMode(Enum):
+    """Enumerates the possible movement modes of the printer."""
+    MOVING = "MOVING"
+    PAUSED = "PAUSED"
+    READY = "READY"
+    WAIT_ON_TOOL = "WAIT_ON_TOOL"
+    HOMING = "HOMING"
+    DEFAULT = "DEFAULT"
+
+
+class Status:
+    """
+    Represents additional status flags parsed from a status line.
+    The meaning of S, L, J, F flags can be specific to printer firmware or model.
+    """
+
+    def __init__(self, data: str):
+        """
+        Creates an instance of Status by parsing a string line.
+        It uses regular expressions to find key-value pairs like "S:0".
+        
+        Args:
+            data: The string line containing status flags (e.g., "Status S:0 L:0 J:0 F:0")
+        """
+        self.s: int = self._get_value(data, "S")
+        self.l: int = self._get_value(data, "L")
+        self.j: int = self._get_value(data, "J")
+        self.f: int = self._get_value(data, "F")
+
+    def _get_value(self, input_str: str, key: str) -> int:
+        """
+        Helper function to extract a numeric value associated with a key from a string.
+        
+        Args:
+            input_str: The string to search within
+            key: The key whose numeric value is to be extracted
+            
+        Returns:
+            The parsed integer value, or -1 if the key is not found or parsing fails
+        """
+        pattern = rf"{key}:(\d+)"
+        match = re.search(pattern, input_str)
+        if match and match.group(1):
+            return int(match.group(1))
+        return -1
+
+
+class Endstop:
+    """
+    Represents the state of the printer's endstops.
+    Typically, a value of 0 means not triggered, and 1 means triggered.
+    """
+
+    def __init__(self, data: str):
+        """
+        Creates an instance of Endstop by parsing a string line.
+        It uses regular expressions to find key-value pairs like "X-max:0".
+        
+        Args:
+            data: The string line containing endstop states (e.g., "Endstop X-max:0 Y-max:0 Z-min:1")
+        """
+        self.x_max: int = self._get_value(data, "X-max")
+        self.y_max: int = self._get_value(data, "Y-max")
+        self.z_min: int = self._get_value(data, "Z-min")
+
+    def _get_value(self, input_str: str, key: str) -> int:
+        """
+        Helper function to extract a numeric value associated with a key from a string.
+        
+        Args:
+            input_str: The string to search within
+            key: The key whose numeric value is to be extracted
+            
+        Returns:
+            The parsed integer value, or -1 if the key is not found or parsing fails
+        """
+        pattern = rf"{key}:(\d+)"
+        match = re.search(pattern, input_str)
+        if match and match.group(1):
+            return int(match.group(1))
+        return -1
+
+
+class EndstopStatus:
+    """
+    Represents the status of the printer's endstops and various other machine states.
+    
+    This information is typically parsed from the response of an M119 command or a similar
+    consolidated status report from the printer. It includes endstop states, machine operational status,
+    movement mode, LED status, and the currently loaded file.
+    """
+
+    def __init__(self):
+        """Initialize a new EndstopStatus instance."""
+        self.endstop: Optional[Endstop] = None
+        self.machine_status: MachineStatus = MachineStatus.DEFAULT
+        self.move_mode: MoveMode = MoveMode.DEFAULT
+        self.status: Optional[Status] = None
+        self.led_enabled: bool = False
+        self.current_file: Optional[str] = None
+
+    def from_replay(self, replay: str) -> Optional['EndstopStatus']:
+        """
+        Parses a raw string replay (typically from an M119 or similar status command)
+        to populate the properties of this EndstopStatus instance.
+        
+        The replay is expected to be a multi-line string where each line provides specific information:
+        - Line 1 (data[0]): Usually a command echo or header, ignored
+        - Line 2 (data[1]): Parsed into the endstop object
+        - Line 3 (data[2]): Parsed to determine machine_status by checking for keywords
+        - Line 4 (data[3]): Parsed to determine move_mode by checking for keywords
+        - Line 5 (data[4]): Parsed into the status object
+        - Line 6 (data[5]): Parsed to determine led_enabled (1 for true, 0 for false)
+        - Line 7 (data[6]): Parsed to get current_file, or None if empty
+        
+        Args:
+            replay: The raw multi-line string response from the printer
+            
+        Returns:
+            The populated EndstopStatus instance, or None if parsing fails
+        """
+        if not replay:
+            return None
+
+        try:
+            data = replay.split('\n')
+
+            # Validate that we have enough lines for a valid response
+            # A valid M119 response should have at least 2 lines (command echo + endstop data)
+            if len(data) < 2:
+                return None
+
+            # Check if the data looks like a valid M119 response
+            # Should contain "Endstop" in the second line
+            if len(data) > 1 and "Endstop" not in data[1]:
+                return None
+
+            # Parse endstop data (line 1)
+            if len(data) > 1:
+                self.endstop = Endstop(data[1])
+
+            # Parse machine status (line 2)
+            if len(data) > 2:
+                machine_status = data[2].replace("MachineStatus: ", "").strip()
+                if "BUILDING_FROM_SD" in machine_status:
+                    self.machine_status = MachineStatus.BUILDING_FROM_SD
+                elif "BUILDING_COMPLETED" in machine_status:
+                    self.machine_status = MachineStatus.BUILDING_COMPLETED
+                elif "PAUSED" in machine_status:
+                    self.machine_status = MachineStatus.PAUSED
+                elif "READY" in machine_status:
+                    self.machine_status = MachineStatus.READY
+                elif "BUSY" in machine_status:
+                    self.machine_status = MachineStatus.BUSY
+                else:
+                    print(f"EndstopStatus: Encountered unknown MachineStatus: {machine_status}")
+                    self.machine_status = MachineStatus.DEFAULT
+
+            # Parse move mode (line 3)
+            if len(data) > 3:
+                move_mode = data[3].replace("MoveMode: ", "").strip()
+                if "MOVING" in move_mode:
+                    self.move_mode = MoveMode.MOVING
+                elif "PAUSED" in move_mode:
+                    self.move_mode = MoveMode.PAUSED
+                elif "READY" in move_mode:
+                    self.move_mode = MoveMode.READY
+                elif "WAIT_ON_TOOL" in move_mode:
+                    self.move_mode = MoveMode.WAIT_ON_TOOL
+                elif "HOMING" in move_mode:
+                    self.move_mode = MoveMode.HOMING
+                else:
+                    print(f"EndstopStatus: Encountered unknown MoveMode: {move_mode}")
+                    self.move_mode = MoveMode.DEFAULT
+
+            # Parse status flags (line 4)
+            if len(data) > 4:
+                self.status = Status(data[4])
+
+            # Parse LED status (line 5)
+            if len(data) > 5:
+                led_str = data[5].replace("LED: ", "").strip()
+                try:
+                    self.led_enabled = int(led_str) == 1
+                except ValueError:
+                    self.led_enabled = False
+
+            # Parse current file (line 6)
+            if len(data) > 6:
+                current_file = data[6].replace("CurrentFile: ", "").strip()
+                self.current_file = current_file if current_file else None
+
+            return self
+
+        except Exception as e:
+            print("Unable to create EndstopStatus instance from replay")
+            print(f"Replay: {replay}")
+            print(f"Error: {e}")
+            return None
+
+    def is_print_complete(self) -> bool:
+        """
+        Checks if the machine status indicates that a print has been completed.
+        
+        Returns:
+            True if machine_status is BUILDING_COMPLETED, False otherwise
+        """
+        return self.machine_status == MachineStatus.BUILDING_COMPLETED
+
+    def is_printing(self) -> bool:
+        """
+        Checks if the machine status indicates that a print is currently in progress from SD.
+        
+        Returns:
+            True if machine_status is BUILDING_FROM_SD, False otherwise
+        """
+        return self.machine_status == MachineStatus.BUILDING_FROM_SD
+
+    def is_ready(self) -> bool:
+        """
+        Checks if the printer is in a ready state (both move mode and machine status are READY).
+        
+        Returns:
+            True if the printer is ready, False otherwise
+        """
+        return (self.move_mode == MoveMode.READY and
+                self.machine_status == MachineStatus.READY)
+
+    def is_paused(self) -> bool:
+        """
+        Checks if the printer is currently paused (either machine status or move mode is PAUSED).
+        
+        Returns:
+            True if the printer is paused, False otherwise
+        """
+        return (self.machine_status == MachineStatus.PAUSED or
+                self.move_mode == MoveMode.PAUSED)
+
+    def __str__(self) -> str:
+        """String representation of the endstop status."""
+        return (f"EndstopStatus(machine={self.machine_status.value}, "
+                f"move={self.move_mode.value}, led={self.led_enabled}, "
+                f"file='{self.current_file}')")
+
+    def __repr__(self) -> str:
+        """Detailed string representation for debugging."""
+        return (f"EndstopStatus("
+                f"endstop={self.endstop}, "
+                f"machine_status={self.machine_status}, "
+                f"move_mode={self.move_mode}, "
+                f"status={self.status}, "
+                f"led_enabled={self.led_enabled}, "
+                f"current_file='{self.current_file}')")