tenma-ps 25.0.0__py3-none-any.whl

tenma_ps/power_supply.py

@@ -0,0 +1,195 @@
+import logging
+from typing import Optional, Type
+
+import serial
+import serial.tools.list_ports
+from tenma import instantiate_tenma_class_from_device_response
+
+logging.basicConfig(level=logging.INFO)
+
+
+class TenmaPs:
+    """
+    Interface for a Tenma power supply device.
+
+    This class manages connection to a Tenma power supply, allowing users to
+    retrieve device status and control voltage/current settings.
+
+    Attributes:
+        VOLTAGE_MULTIPLIER (float): Multiplier to convert volts to millivolts.
+        CURRENT_MULTIPLIER (float): Multiplier to convert amps to milliamps.
+
+    Example:
+        ```python
+        from tenma_ps.power_supply import TenmaPs
+
+        with TenmaPs("COM4") as tenma_ps:
+            print("Device version:", tenma_ps.get_version())
+            print("Device status:", tenma_ps.get_status())
+
+            # Set voltage and current on channel 1
+            tenma_ps.set_voltage(channel=1, voltage=5.0)
+            tenma_ps.set_current(channel=1, current=1.0)
+
+            # Read voltage and current from channel 1
+            voltage = tenma_ps.read_voltage(channel=1)
+            current = tenma_ps.read_current(channel=1)
+            print(f"Channel 1 Voltage: {voltage} V")
+            print(f"Channel 1 Current: {current} A")
+
+            # Turn on and off the power supply
+            tenma_ps.turn_on()
+            print("Power supply turned ON.")
+            tenma_ps.turn_off()
+            print("Power supply turned OFF.")
+        ```
+    """
+
+    VOLTAGE_MULTIPLIER: float = 1000.0  # To convert volts to millivolts
+    CURRENT_MULTIPLIER: float = 1000.0  # To convert amps to milliamps
+
+    def __init__(self, port: str) -> None:
+        """
+        Initialize the Tenma power supply interface.
+
+        Args:
+            port (str): The COM port (e.g., "COM4") to which the device is connected.
+
+        Raises:
+            Exception: If the connection to the device fails.
+        """
+        self._close_com_port_if_open(port)
+        self.device = instantiate_tenma_class_from_device_response(port)
+
+    def _close_com_port_if_open(self, port: str) -> None:
+        """
+        Close the COM port if it is already open.
+
+        Args:
+            port (str): The COM port to check and close if open.
+
+        Logs:
+            Logs a message if the port is successfully closed.
+            Logs an error if there is an issue closing the port.
+        """
+        try:
+            for p in serial.tools.list_ports.comports():
+                if p.device == port:
+                    try:
+                        with serial.Serial(port) as ser:
+                            if ser.is_open:
+                                ser.close()
+                                logging.info(f"Closed COM port: {port}")
+                    except serial.SerialException as e:
+                        logging.error(f"Error closing COM port {port}: {e}")
+        except Exception as e:
+            logging.error(f"Unexpected error closing COM port {port}: {e}")
+
+    def get_version(self) -> str:
+        """
+        Get the version information of the Tenma power supply.
+
+        Returns:
+            str: The version string reported by the device.
+        """
+        return self.device.getVersion()
+
+    def get_status(self) -> str:
+        """
+        Get the current status of the Tenma power supply.
+
+        Returns:
+            str: The status string reported by the device.
+        """
+        return self.device.getStatus()
+
+    def turn_on(self) -> None:
+        """
+        Power on the Tenma power supply.
+        """
+        self.device.ON()
+
+    def turn_off(self) -> None:
+        """
+        Power off the Tenma power supply.
+        """
+        self.device.OFF()
+
+    def read_voltage(self, channel: int) -> float:
+        """
+        Read the voltage from a specified channel.
+
+        Args:
+            channel (int): The channel number to read from.
+
+        Returns:
+            float: The voltage value in volts.
+        """
+        return self.device.runningVoltage(channel)
+
+    def read_current(self, channel: int) -> float:
+        """
+        Read the current from a specified channel.
+
+        Args:
+            channel (int): The channel number to read from.
+
+        Returns:
+            float: The current value in amps.
+        """
+        return self.device.runningCurrent(channel)
+
+    def set_voltage(self, channel: int, voltage: float) -> None:
+        """
+        Set the voltage for a specified channel.
+
+        Args:
+            channel (int): The channel number to set.
+            voltage (float): The voltage value in volts.
+        """
+        self.device.setVoltage(channel, voltage * self.VOLTAGE_MULTIPLIER)
+
+    def set_current(self, channel: int, current: float) -> None:
+        """
+        Set the current for a specified channel.
+
+        Args:
+            channel (int): The channel number to set.
+            current (float): The current value in amps.
+        """
+        self.device.setCurrent(channel, current * self.CURRENT_MULTIPLIER)
+
+    def close(self) -> None:
+        """
+        Close the connection to the Tenma power supply.
+        """
+        self.device.close()
+
+    def __enter__(self) -> "TenmaPs":
+        """
+        Enter the runtime context for the TenmaPs object.
+
+        Returns:
+            TenmaPs: The TenmaPs instance.
+        """
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[object]
+    ) -> None:
+        """
+        Exit the runtime context and clean up resources.
+
+        Args:
+            exc_type (Optional[Type[BaseException]]): Exception type, if any.
+            exc_value (Optional[BaseException]): Exception value, if any.
+            traceback (Optional[object]): Traceback object, if any.
+        """
+        self.close()
+
+
+if __name__ == "__main__":
+    pass

tenma_ps/ps_fastapi.py

@@ -0,0 +1,212 @@
+import socket
+from fastapi import FastAPI, HTTPException, Query
+from pydantic import BaseModel
+from typing import Optional
+
+from tenma_ps.power_supply import TenmaPs
+
+app = FastAPI(
+    title="Tenma Power Supply API",
+    description=(
+        "API for controlling and monitoring a Tenma power supply via the [`TenmaPs`](power_supply.py) class. "
+        "See `/docs` for interactive documentation."
+    ),
+    version="1.0.0"
+)
+
+# Singleton device instance (for demo/simple use)
+device: Optional[TenmaPs] = None
+
+# ------------------- Pydantic Models -------------------
+
+class ConnectRequest(BaseModel):
+    """Request model for connecting to a COM port."""
+    port: str
+
+class SetChannelValueRequest(BaseModel):
+    """Request model for setting a single value (voltage or current) on a channel."""
+    channel: int
+    value: float
+
+class SetVoltageCurrentRequest(BaseModel):
+    """Request model for setting both voltage and current on a channel."""
+    channel: int
+    voltage: float
+    current: float
+
+# ------------------- API Endpoints -------------------
+
+@app.get("/", tags=["Info"])
+def root():
+    """
+    Root endpoint.
+
+    Returns links to API documentation.
+    """
+    return {
+        "message": "Welcome to Tenma Power Supply API.",
+        "docs": "/docs",
+        "redoc": "/redoc"
+    }
+
+@app.post("/connect", tags=["Connection"])
+def connect(req: ConnectRequest):
+    """
+    Connect to the Tenma power supply on the specified COM port.
+
+    - **port**: Serial port name (e.g., "COM4")
+    """
+    global device
+    try:
+        device = TenmaPs(req.port)
+        return {"status": "connected", "port": req.port}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to connect: {e}")
+
+@app.post("/disconnect", tags=["Connection"])
+def disconnect():
+    """
+    Disconnect from the Tenma power supply.
+    """
+    global device
+    if device is not None:
+        try:
+            device.close()
+            device = None
+            return {"status": "disconnected"}
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to disconnect: {e}")
+    else:
+        raise HTTPException(status_code=400, detail="No device connected.")
+
+@app.get("/version", tags=["Device Info"])
+def get_version():
+    """
+    Get the version information of the connected Tenma power supply.
+    """
+    if device is None:
+        raise HTTPException(status_code=400, detail="No device connected.")
+    return {"version": device.get_version()}
+
+@app.get("/status", tags=["Device Info"])
+def get_status():
+    """
+    Get the current status of the connected Tenma power supply.
+    """
+    if device is None:
+        raise HTTPException(status_code=400, detail="No device connected.")
+    return {"status": device.get_status()}
+
+@app.post("/turn_on", tags=["Output Control"])
+def turn_on():
+    """
+    Turn ON the power supply output.
+    """
+    if device is None:
+        raise HTTPException(status_code=400, detail="No device connected.")
+    device.turn_on()
+    return {"output": "on"}
+
+@app.post("/turn_off", tags=["Output Control"])
+def turn_off():
+    """
+    Turn OFF the power supply output.
+    """
+    if device is None:
+        raise HTTPException(status_code=400, detail="No device connected.")
+    device.turn_off()
+    return {"output": "off"}
+
+@app.get("/read_voltage", tags=["Read"])
+def read_voltage(channel: int = Query(..., description="Channel number")):
+    """
+    Read the voltage from a specified channel.
+
+    - **channel**: Channel number to read voltage from.
+    """
+    if device is None:
+        raise HTTPException(status_code=400, detail="No device connected.")
+    voltage = device.read_voltage(channel)
+    return {"channel": channel, "voltage": voltage}
+
+@app.get("/read_current", tags=["Read"])
+def read_current(channel: int = Query(..., description="Channel number")):
+    """
+    Read the current from a specified channel.
+
+    - **channel**: Channel number to read current from.
+    """
+    if device is None:
+        raise HTTPException(status_code=400, detail="No device connected.")
+    current = device.read_current(channel)
+    return {"channel": channel, "current": current}
+
+@app.post("/set_voltage", tags=["Set"])
+def set_voltage(req: SetChannelValueRequest):
+    """
+    Set the voltage for a specified channel.
+
+    - **channel**: Channel number to set voltage on.
+    - **value**: Voltage value in volts.
+    """
+    if device is None:
+        raise HTTPException(status_code=400, detail="No device connected.")
+    device.set_voltage(req.channel, req.value)
+    return {"channel": req.channel, "voltage": req.value}
+
+@app.post("/set_current", tags=["Set"])
+def set_current(req: SetChannelValueRequest):
+    """
+    Set the current for a specified channel.
+
+    - **channel**: Channel number to set current on.
+    - **value**: Current value in amps.
+    """
+    if device is None:
+        raise HTTPException(status_code=400, detail="No device connected.")
+    device.set_current(req.channel, req.value)
+    return {"channel": req.channel, "current": req.value}
+
+@app.post("/set_voltage_current", tags=["Set"])
+def set_voltage_current(req: SetVoltageCurrentRequest):
+    """
+    Set both voltage and current for a specified channel.
+
+    - **channel**: Channel number to set.
+    - **voltage**: Voltage value in volts.
+    - **current**: Current value in amps.
+    """
+    if device is None:
+        raise HTTPException(status_code=400, detail="No device connected.")
+    device.set_voltage(req.channel, req.voltage)
+    device.set_current(req.channel, req.current)
+    return {"channel": req.channel, "voltage": req.voltage, "current": req.current}
+
+# ------------------- Example Usage -------------------
+"""
+Example usage with HTTPie or curl:
+
+1. Connect to device:
+    http POST http://localhost:8000/connect port="COM4"
+
+2. Get device version:
+    http GET http://localhost:8000/version
+
+3. Set voltage and current on channel 1:
+    http POST http://localhost:8000/set_voltage_current channel=1 voltage=5.0 current=1.0
+
+4. Read voltage:
+    http GET http://localhost:8000/read_voltage channel==1
+
+5. Turn ON output:
+    http POST http://localhost:8000/turn_on
+
+6. Disconnect:
+    http POST http://localhost:8000/disconnect
+
+Interactive API docs: http://localhost:8000/docs
+"""
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("tenma_ps.ps_fastapi:app", host=socket.getfqdn(), reload=True)

tenma_ps/ps_gui.py

@@ -0,0 +1,403 @@
+import threading
+import time
+import queue
+import customtkinter as ctk
+from tkinter import StringVar, IntVar
+import serial.tools.list_ports
+import sys
+import signal
+
+from tenma_ps.power_supply import TenmaPs
+
+ctk.set_appearance_mode("dark")
+ctk.set_default_color_theme("dark-blue")
+
+
+class PsGui(ctk.CTk):
+    """
+    GUI for controlling and monitoring a Tenma power supply.
+
+    Features:
+        - Serial port selection and connection management
+        - Read device version
+        - Turn power supply ON/OFF
+        - Set voltage and current for a specific channel
+        - Live display of voltage and current for a selected channel
+    """
+
+    def __init__(self):
+        """Initialize the GUI and set up all widgets and background threads."""
+        super().__init__()
+        self.title("Tenma Power Supply GUI")
+        self.geometry("540x410")
+        self.resizable(False, False)
+
+        # Device state
+        self.device: TenmaPs | None = None
+        self.is_connected = False
+        self.is_monitoring = False
+
+        # Tkinter variables for UI state
+        self.selected_port = StringVar()
+        self.read_channel_var = IntVar(value=1)
+        self.live_voltage_var = StringVar(value="Voltage: -- V")
+        self.live_current_var = StringVar(value="Current: -- A")
+        self.device_version_var = StringVar(value="Version: --")
+
+        # For set voltage/current section
+        self.set_channel_var = IntVar(value=1)
+        self.set_voltage_var = StringVar(value="12.50")
+        self.set_current_var = StringVar(value="5.00")
+
+        # UI style
+        self._button_font = ctk.CTkFont(weight="bold", size=14)
+        self._button_text_color = "#ffffff"
+
+        # Threading/worker
+        self._action_queue = queue.Queue()
+        self._worker_thread = threading.Thread(target=self._process_action_queue, daemon=True)
+        self._worker_thread.start()
+        self._monitor_thread = None
+
+        self._build_gui()
+
+        # Ensure power supply is closed on exit/signals
+        self.protocol("WM_DELETE_WINDOW", self._on_close)
+        signal.signal(signal.SIGINT, self._on_signal_exit)
+        signal.signal(signal.SIGTERM, self._on_signal_exit)
+
+    # ---------------- GUI Layout ----------------
+
+    def _build_gui(self):
+        """Build and layout all GUI sections and widgets."""
+
+        # --- Serial Port Selection (all items in one row) ---
+        section_serial = ctk.CTkFrame(self, border_color="#1abc9c", border_width=2)
+        section_serial.pack(padx=15, pady=(15, 10), fill="x")
+
+        row_serial = ctk.CTkFrame(section_serial, fg_color="transparent")
+        row_serial.pack(padx=10, pady=10, fill="x")
+
+        ctk.CTkLabel(row_serial, text="Serial Port Selection:", font=ctk.CTkFont(weight="bold")).pack(side="left", padx=(0, 10))
+        self.combobox_ports = ctk.CTkComboBox(
+            row_serial, values=self._get_available_com_ports(), variable=self.selected_port, width=180
+        )
+        self.combobox_ports.pack(side="left", padx=(0, 10))
+        self.button_connect = ctk.CTkButton(
+            row_serial,
+            text="Connect",
+            command=lambda: self._enqueue_action(self._toggle_connection),
+            fg_color="#e74c3c",
+            font=self._button_font,
+            text_color=self._button_text_color,
+            hover_color="#ff7675"
+        )
+        self.button_connect.pack(side="left")
+
+        # --- Device Version section ---
+        section_version = ctk.CTkFrame(self, border_color="#2980b9", border_width=2)
+        section_version.pack(padx=15, pady=10, fill="x")
+        self.button_version = ctk.CTkButton(
+            section_version,
+            text="Read Version",
+            command=lambda: self._enqueue_action(self._read_device_version),
+            state="disabled",
+            font=self._button_font,
+            text_color=self._button_text_color,
+            fg_color="#2980b9",
+            hover_color="#74b9ff"
+        )
+        self.button_version.pack(padx=10, pady=10, side="left")
+        self.label_version = ctk.CTkLabel(
+            section_version, textvariable=self.device_version_var, font=ctk.CTkFont(size=14, weight="bold")
+        )
+        self.label_version.pack(padx=10, pady=10, side="left")
+
+        # --- Power Control section (Turn ON/OFF) ---
+        section_power = ctk.CTkFrame(self, border_color="#9b59b6", border_width=2)
+        section_power.pack(padx=15, pady=10, fill="x")
+
+        power_row = ctk.CTkFrame(section_power, fg_color="transparent")
+        power_row.pack(padx=10, pady=10, fill="x")
+
+        self.button_on = ctk.CTkButton(
+            power_row,
+            text="Turn ON",
+            command=lambda: self._enqueue_action(self._turn_output_on),
+            state="disabled",
+            fg_color="#27ae60",
+            font=self._button_font,
+            text_color=self._button_text_color,
+            hover_color="#00ff99",
+            width=200,
+            height=36
+        )
+        self.button_on.pack(side="left", padx=(0, 20), fill="x", expand=True)
+        self.button_off = ctk.CTkButton(
+            power_row,
+            text="Turn OFF",
+            command=lambda: self._enqueue_action(self._turn_output_off),
+            state="disabled",
+            fg_color="#c0392b",
+            font=self._button_font,
+            text_color=self._button_text_color,
+            hover_color="#ff7675",
+            width=200,
+            height=36
+        )
+        self.button_off.pack(side="left", padx=(0, 0), fill="x", expand=True)
+
+        # --- Set Voltage/Current for Channel section ---
+        section_set = ctk.CTkFrame(self, border_color="#e67e22", border_width=2)
+        section_set.pack(padx=15, pady=10, fill="x")
+
+        set_row = ctk.CTkFrame(section_set, fg_color="transparent")
+        set_row.pack(padx=10, pady=15, fill="x")
+
+        ctk.CTkLabel(set_row, text="Channel:", font=ctk.CTkFont(weight="bold")).pack(side="left")
+        self.set_channel_entry = ctk.CTkEntry(
+            set_row, textvariable=self.set_channel_var, width=40, font=ctk.CTkFont(weight="bold"), state="disabled"
+        )
+        self.set_channel_entry.pack(side="left", padx=(5, 15))
+
+        ctk.CTkLabel(set_row, text="Voltage (V):", font=ctk.CTkFont(weight="bold")).pack(side="left")
+        self.set_voltage_entry = ctk.CTkEntry(
+            set_row, textvariable=self.set_voltage_var, width=60, font=ctk.CTkFont(weight="bold"), state="disabled"
+        )
+        self.set_voltage_entry.pack(side="left", padx=(5, 15))
+
+        ctk.CTkLabel(set_row, text="Current (A):", font=ctk.CTkFont(weight="bold")).pack(side="left")
+        self.set_current_entry = ctk.CTkEntry(
+            set_row, textvariable=self.set_current_var, width=60, font=ctk.CTkFont(weight="bold"), state="disabled"
+        )
+        self.set_current_entry.pack(side="left", padx=(5, 15))
+
+        self.button_set = ctk.CTkButton(
+            set_row,
+            text="Set",
+            command=lambda: self._enqueue_action(self._set_channel_voltage_current),
+            state="disabled",
+            fg_color="#16a085",
+            font=self._button_font,
+            text_color=self._button_text_color,
+            hover_color="#1abc9c"
+        )
+        self.button_set.pack(side="left", padx=(10, 0))
+
+        # --- Live Voltage/Current Reading section ---
+        section_read = ctk.CTkFrame(self, border_color="#34495e", border_width=2)
+        section_read.pack(padx=15, pady=10, fill="x")
+
+        row_read = ctk.CTkFrame(section_read, fg_color="transparent")
+        row_read.pack(padx=10, pady=15, fill="x")
+
+        ctk.CTkLabel(row_read, text="Channel:", font=ctk.CTkFont(weight="bold")).pack(side="left")
+        self.read_channel_entry = ctk.CTkEntry(
+            row_read, textvariable=self.read_channel_var, width=40, font=ctk.CTkFont(weight="bold")
+        )
+        self.read_channel_entry.pack(side="left", padx=(5, 20))
+
+        self.label_voltage = ctk.CTkLabel(
+            row_read, textvariable=self.live_voltage_var, font=ctk.CTkFont(size=16, weight="bold")
+        )
+        self.label_voltage.pack(side="left", padx=(0, 20))
+        self.label_current = ctk.CTkLabel(
+            row_read, textvariable=self.live_current_var, font=ctk.CTkFont(size=16, weight="bold")
+        )
+        self.label_current.pack(side="left")
+
+    # ---------------- Serial Port Helpers ----------------
+
+    def _get_available_com_ports(self):
+        """Return a list of available COM port device names."""
+        return [p.device for p in serial.tools.list_ports.comports()]
+
+    # ---------------- Action Queue/Worker ----------------
+
+    def _enqueue_action(self, func):
+        """Add a function to the action queue to be executed in the worker thread."""
+        self._action_queue.put(func)
+
+    def _process_action_queue(self):
+        """Continuously process actions from the queue in a background thread."""
+        while True:
+            func = self._action_queue.get()
+            try:
+                func()
+            except Exception as e:
+                self._show_error_mainthread(f"Error: {e}")
+            self._action_queue.task_done()
+
+    # ---------------- Device Actions ----------------
+
+    def _toggle_connection(self):
+        """Connect or disconnect from the power supply based on current state."""
+        if not self.is_connected:
+            port = self.selected_port.get()
+            if not port:
+                self._show_error_mainthread("Please select a COM port.")
+                return
+            try:
+                self.device = TenmaPs(port)
+                self.is_connected = True
+                self._after_mainthread(self._on_connect_success)
+            except Exception as e:
+                self._show_error_mainthread(f"Failed to connect: {e}")
+        else:
+            self._disconnect_device()
+
+    def _on_connect_success(self):
+        """Update UI after successful connection."""
+        self.button_connect.configure(text="Disconnect", fg_color="#27ae60")
+        self.combobox_ports.configure(state="disabled")
+        self.button_on.configure(state="normal")
+        self.button_off.configure(state="normal")
+        self.button_version.configure(state="normal")
+        self.button_set.configure(state="normal")
+        self.set_channel_entry.configure(state="normal")
+        self.set_voltage_entry.configure(state="normal")
+        self.set_current_entry.configure(state="normal")
+        self._start_monitoring()
+
+    def _disconnect_device(self):
+        """Disconnect from the power supply and reset UI."""
+        self._stop_monitoring()
+        if self.device:
+            try:
+                self.device.close()
+            except Exception:
+                pass
+        self.device = None
+        self.is_connected = False
+        self.button_connect.configure(text="Connect", fg_color="#e74c3c")
+        self.combobox_ports.configure(state="normal")
+        self.button_on.configure(state="disabled")
+        self.button_off.configure(state="disabled")
+        self.button_version.configure(state="disabled")
+        self.button_set.configure(state="disabled")
+        self.set_channel_entry.configure(state="disabled")
+        self.set_voltage_entry.configure(state="disabled")
+        self.set_current_entry.configure(state="disabled")
+        self.live_voltage_var.set("Voltage: -- V")
+        self.live_current_var.set("Current: -- A")
+        self.device_version_var.set("Version: --")
+
+    def _start_monitoring(self):
+        """Start background thread to monitor live voltage and current."""
+        self.is_monitoring = True
+        self._monitor_thread = threading.Thread(target=self._monitor_live_values, daemon=True)
+        self._monitor_thread.start()
+
+    def _stop_monitoring(self):
+        """Stop the background monitoring thread."""
+        self.is_monitoring = False
+        if self._monitor_thread and self._monitor_thread.is_alive():
+            self._monitor_thread.join(timeout=1)
+
+    def _monitor_live_values(self):
+        """Continuously read voltage and current from the selected channel and update the UI."""
+        while self.is_monitoring and self.device:
+            try:
+                channel = self.read_channel_var.get()
+                voltage = self.device.read_voltage(channel=channel)
+                current = self.device.read_current(channel=channel)
+                self._after_mainthread(lambda: self.live_voltage_var.set(f"Voltage: {voltage:.2f} V"))
+                self._after_mainthread(lambda: self.live_current_var.set(f"Current: {current:.2f} A"))
+            except Exception:
+                self._after_mainthread(lambda: self.live_voltage_var.set("Voltage: -- V"))
+                self._after_mainthread(lambda: self.live_current_var.set("Current: -- A"))
+            time.sleep(1)
+
+    def _turn_output_on(self):
+        """Turn ON the power supply output."""
+        if self.device:
+            try:
+                self.device.turn_on()
+                self._after_mainthread(lambda: self.button_on.configure(state="disabled"))
+                self._after_mainthread(lambda: self.button_off.configure(state="normal"))
+            except Exception as e:
+                self._show_error_mainthread(f"Failed to turn ON: {e}")
+
+    def _turn_output_off(self):
+        """Turn OFF the power supply output."""
+        if self.device:
+            try:
+                self.device.turn_off()
+                self._after_mainthread(lambda: self.button_on.configure(state="normal"))
+                self._after_mainthread(lambda: self.button_off.configure(state="disabled"))
+            except Exception as e:
+                self._show_error_mainthread(f"Failed to turn OFF: {e}")
+
+    def _read_device_version(self):
+        """Read and display the device version."""
+        if self.device:
+            try:
+                version = self.device.get_version()
+                self._after_mainthread(lambda: self.device_version_var.set(f"Version: {version}"))
+            except Exception as e:
+                self._after_mainthread(lambda: self.device_version_var.set("Version: --"))
+                self._show_error_mainthread(f"Failed to read version: {e}")
+
+    def _set_channel_voltage_current(self):
+        """Set voltage and current for the specified channel using the set section."""
+        if self.device:
+            try:
+                channel = self.set_channel_var.get()
+                voltage_input = self.set_voltage_var.get()
+                current_input = self.set_current_var.get()
+
+                # Validate voltage and current inputs
+                try:
+                    voltage = float(voltage_input)
+                except ValueError:
+                    raise ValueError(f"Invalid voltage input: '{voltage_input}'")
+
+                try:
+                    current = float(current_input)
+                except ValueError:
+                    raise ValueError(f"Invalid current input: '{current_input}'")
+
+                self.device.set_voltage(channel=channel, voltage=voltage)
+                self.device.set_current(channel=channel, current=current)
+            except Exception as e:
+                self._show_error_mainthread(f"Failed to set voltage/current: {e}")
+
+    # ---------------- Thread-safe GUI update helpers ----------------
+
+    def _after_mainthread(self, func):
+        """Schedule a function to run on the main thread."""
+        self.after(0, func)
+
+    def _show_error_mainthread(self, message):
+        """Show an error message in a thread-safe way."""
+        self._after_mainthread(lambda: self._show_error_popup(message))
+
+    def _show_error_popup(self, message):
+        """Display an error message in a popup window."""
+        error_win = ctk.CTkToplevel(self)
+        error_win.title("Error")
+        error_win.geometry("300x100")
+        ctk.CTkLabel(error_win, text=message, text_color="red", font=ctk.CTkFont(weight="bold", size=13)).pack(padx=20, pady=20)
+        ctk.CTkButton(error_win, text="OK", command=error_win.destroy, font=self._button_font, text_color=self._button_text_color).pack(pady=(0, 10))
+
+    # ---------------- Cleanup/Exit ----------------
+
+    def _on_close(self):
+        """Handle GUI close event and ensure power supply is closed."""
+        self._stop_monitoring()
+        if self.device:
+            try:
+                self.device.close()
+            except Exception:
+                pass
+        self.destroy()
+
+    def _on_signal_exit(self, signum, frame):
+        """Handle process signals to ensure power supply is closed."""
+        self._on_close()
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    app = PsGui()
+    app.mainloop()

tenma_ps-25.0.0.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.3
+Name: tenma-ps
+Version: 25.0.0
+Summary: python package for controlling tenma power supply
+Keywords: python,tenma,power,supply,application
+Author: chaitu-ycr
+Author-email: chaitu-ycr <chaitu.ycr@gmail.com>
+License: MIT License
+         
+         Copyright (c) 2025 chaitu-ycr
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Dist: tenma-serial
+Requires-Dist: customtkinter
+Requires-Dist: fastapi[all]
+Requires-Python: >=3.10, <=3.14
+Project-URL: documentation, https://chaitu-ycr.github.io/automotive-test-kit/packages/tenma_ps
+Project-URL: homepage, https://github.com/chaitu-ycr/automotive-test-kit
+Project-URL: repository, https://github.com/chaitu-ycr/automotive-test-kit
+Description-Content-Type: text/markdown
+
+# tenma_ps
+
+python package for controlling tenma power supply
+
+## [source manual](https://chaitu-ycr.github.io/automotive-test-kit/packages/tenma_ps/#source-manual)

tenma_ps-25.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+tenma_ps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tenma_ps/power_supply.py,sha256=sdRl9zoONHmR9nraouvBYlAjSzrP3bFbgRSiMetFFRc,6119
+tenma_ps/ps_fastapi.py,sha256=fM-lBjxFCiqdqGdbnrwdBtKxvziW_cegs8iv_-OM5YM,6649
+tenma_ps/ps_gui.py,sha256=QIZ1w3mExz7dUdl7H21DDSHgR5tQc7mAqwzxa4Eg5CY,17033
+tenma_ps-25.0.0.dist-info/WHEEL,sha256=5h_Q-_6zWQhhADpsAD_Xpw7gFbCRK5WjOOEq0nB806Q,79
+tenma_ps-25.0.0.dist-info/METADATA,sha256=PxhqqQa3_Hapfdvu2XQ-UhPn6DpPhuiiSDSq9gLjvlY,2206
+tenma_ps-25.0.0.dist-info/RECORD,,

tenma_ps-25.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.18
+Root-Is-Purelib: true
+Tag: py3-none-any