pyfactoryio 0.1.0__py3-none-any.whl

pyfactoryio/__init__.py

@@ -0,0 +1,2 @@
+from pyfactoryio.server import FactoryIOServer
+from pyfactoryio.gui import FactoryIOGUI

pyfactoryio/gui.py

@@ -0,0 +1,97 @@
+import tkinter as tk
+from pyModbusTCP.server import ModbusServer
+
+
+class FactoryIOGUI:
+    def __init__(self, master, server, di_names=None, do_names=None, ri_names=None, ro_names=None):
+        self.master = master
+        self.master.title("Factory I/O Modbus Server Interface")
+        self.master.geometry("800x600")
+        self.master.configure(padx=20, pady=20)
+        self.server = server
+
+        di_count = len(di_names) if di_names else 0
+        do_count = len(do_names) if do_names else 0
+        ri_count = len(ri_names) if ri_names else 0
+        ro_count = len(ro_names) if ro_names else 0
+
+        self.frame_di = tk.LabelFrame(master, text="Digital Inputs (Sensors)", padx=10, pady=10)
+        self.frame_do = tk.LabelFrame(master, text="Digital Outputs (Actuators)", padx=10, pady=10)
+        self.frame_ri = tk.LabelFrame(master, text="Register Inputs (Sensors)", padx=10, pady=10)
+        self.frame_ro = tk.LabelFrame(master, text="Register Outputs (Actuators)", padx=10, pady=10)
+
+        cols = sum(1 for c in [di_count, do_count, ri_count, ro_count] if c > 0)
+        col = 0
+        if di_count:
+            self.frame_di.grid(row=0, column=col, padx=10, pady=10, sticky="n")
+            col += 1
+        if do_count:
+            self.frame_do.grid(row=0, column=col, padx=10, pady=10, sticky="n")
+            col += 1
+        if ri_count:
+            self.frame_ri.grid(row=0, column=col, padx=10, pady=10, sticky="n")
+            col += 1
+        if ro_count:
+            self.frame_ro.grid(row=0, column=col, padx=10, pady=10, sticky="n")
+
+        self.di_labels = []
+        for i, name in enumerate(di_names or []):
+            lbl = tk.Label(self.frame_di, text=name, bg="gray", fg="white", width=20)
+            lbl.grid(row=i, column=0, pady=2)
+            self.di_labels.append(lbl)
+
+        self.do_vars = []
+        for i, name in enumerate(do_names or []):
+            var = tk.IntVar()
+            chk = tk.Checkbutton(self.frame_do, text=name, variable=var,
+                                 command=lambda i=i, v=var: self.write_digital_output(i, v))
+            chk.grid(row=i, column=0, pady=2, sticky="w")
+            self.do_vars.append(var)
+
+        self.ri_labels = []
+        for i, name in enumerate(ri_names or []):
+            lbl = tk.Label(self.frame_ri, text=f"{name}: 0", font=("Arial", 10, "bold"), width=20, anchor="w")
+            lbl.grid(row=i, column=0, pady=2)
+            self.ri_labels.append(lbl)
+
+        self.ro_entries = []
+        for i, name in enumerate(ro_names or []):
+            frame = tk.Frame(self.frame_ro)
+            frame.grid(row=i, column=0, pady=2)
+            tk.Label(frame, text=f"{name}: ").pack(side=tk.LEFT)
+            entry = tk.Entry(frame, width=10)
+            entry.insert(0, "0")
+            entry.pack(side=tk.LEFT)
+            entry.bind("<Return>", lambda event, i=i, e=entry: self.write_register_output(i, e))
+            self.ro_entries.append(entry)
+
+        self.update_gui_from_server()
+
+    def update_gui_from_server(self):
+        di_data = self.server.get_digital_inputs()
+        for i, lbl in enumerate(self.di_labels):
+            if i < len(di_data):
+                color = "green" if di_data[i] else "gray"
+                lbl.config(bg=color)
+
+        ri_data = self.server.get_register_inputs()
+        for i, lbl in enumerate(self.ri_labels):
+            if i < len(ri_data):
+                lbl.config(text=f"{self.ri_labels[i].cget('text').split(':')[0]}: {ri_data[i]}")
+
+        self.master.after(50, self.update_gui_from_server)
+
+    def write_digital_output(self, index, var):
+        val = bool(var.get())
+        self.server.set_digital_output(index, val)
+
+    def write_register_output(self, index, entry):
+        try:
+            val = int(entry.get())
+            self.server.set_register_output(index, val)
+        except ValueError:
+            print("Please enter a valid integer.")
+
+    def on_closing(self):
+        self.server.stop()
+        self.master.destroy()

pyfactoryio/server.py

@@ -0,0 +1,145 @@
+from pyModbusTCP.server import ModbusServer
+
+
+class FactoryIOServer:
+    def __init__(self, host="127.0.0.1", port=5020, di_names=None, do_names=None, ri_names=None, ro_names=None):
+        self.host = host
+        self.port = port
+        self.server = ModbusServer(host=host, port=port, no_block=True)
+        self.di_offset = 0
+        self.do_offset = 16
+        self.ri_offset = 0
+        self.ro_offset = 8
+        
+        self.di_names = di_names or []
+        self.do_names = do_names or []
+        self.ri_names = ri_names or []
+        self.ro_names = ro_names or []
+
+        self._di_map = {name: i for i, name in enumerate(self.di_names)}
+        self._do_map = {name: i for i, name in enumerate(self.do_names)}
+        self._ri_map = {name: i for i, name in enumerate(self.ri_names)}
+        self._ro_map = {name: i for i, name in enumerate(self.ro_names)}
+        
+        self._callbacks = {}
+        self._running = False
+
+    def on_change(self, name):
+        """Decorator to register a callback when a variable changes state."""
+        def decorator(func):
+            if name not in self._callbacks:
+                self._callbacks[name] = []
+            self._callbacks[name].append(func)
+            return func
+        return decorator
+
+    def run_loop(self, logic_func=None, hz=10):
+        """Runs a continuous control loop, executing logic_func and monitoring events."""
+        import time
+        if not self.server.is_run:
+            self.start()
+            
+        self._running = True
+        delay = 1.0 / hz
+        
+        # Initialize previous states for all mapped variables
+        prev_state = {}
+        all_names = self.di_names + self.ri_names + self.do_names + self.ro_names
+        for name in all_names:
+            prev_state[name] = getattr(self, name)
+
+        print(f"Starting control loop at {hz}Hz. Press Ctrl+C to stop.")
+        try:
+            while self._running:
+                # 1. Detect changes and fire callbacks
+                for name in all_names:
+                    current_val = getattr(self, name)
+                    if current_val != prev_state[name]:
+                        prev_state[name] = current_val
+                        for cb in self._callbacks.get(name, []):
+                            cb(current_val)
+                
+                # 2. Run user logic
+                if logic_func:
+                    logic_func(self)
+                    
+                time.sleep(delay)
+        except KeyboardInterrupt:
+            print("Loop interrupted by user.")
+        finally:
+            self._running = False
+            self.stop()
+
+    def __getattr__(self, name):
+        if name in self.__dict__.get('_di_map', {}):
+            index = self._di_map[name]
+            data = self.server.data_bank.get_coils(self.di_offset + index, 1)
+            return bool(data[0]) if data else False
+            
+        if name in self.__dict__.get('_ri_map', {}):
+            index = self._ri_map[name]
+            data = self.server.data_bank.get_holding_registers(self.ri_offset + index, 1)
+            if data:
+                val = data[0]
+                return val - 65536 if val > 32767 else val
+            return 0
+            
+        if name in self.__dict__.get('_do_map', {}):
+            index = self._do_map[name]
+            data = self.server.data_bank.get_discrete_inputs(self.do_offset + index, 1)
+            return bool(data[0]) if data else False
+            
+        if name in self.__dict__.get('_ro_map', {}):
+            index = self._ro_map[name]
+            data = self.server.data_bank.get_input_registers(self.ro_offset + index, 1)
+            if data:
+                val = data[0]
+                return val - 65536 if val > 32767 else val
+            return 0
+            
+        raise AttributeError(f"'FactoryIOServer' object has no attribute '{name}'")
+
+    def __setattr__(self, name, value):
+        if hasattr(self, '_do_map') and name in self._do_map:
+            index = self._do_map[name]
+            self.set_digital_output(index, value)
+            return
+            
+        if hasattr(self, '_ro_map') and name in self._ro_map:
+            index = self._ro_map[name]
+            self.set_register_output(index, value)
+            return
+            
+        if hasattr(self, '_di_map') and name in self._di_map:
+            raise AttributeError(f"Cannot set digital input '{name}', it is read-only (written by Factory I/O).")
+            
+        if hasattr(self, '_ri_map') and name in self._ri_map:
+            raise AttributeError(f"Cannot set register input '{name}', it is read-only (written by Factory I/O).")
+            
+        super().__setattr__(name, value)
+
+    def start(self):
+        self.server.start()
+        print(f"Modbus Server Started on {self.host}:{self.port}")
+
+    def stop(self):
+        self.server.stop()
+
+    def get_digital_inputs(self):
+        data = self.server.data_bank.get_coils(self.di_offset, 16)
+        return list(data) if data else [False] * 16
+
+    def get_register_inputs(self):
+        data = self.server.data_bank.get_holding_registers(self.ri_offset, 8)
+        if data:
+            return [val - 65536 if val > 32767 else val for val in data]
+        return [0] * 8
+
+    def set_digital_output(self, index, value):
+        self.server.data_bank.set_discrete_inputs(self.do_offset + index, [bool(value)])
+
+    def set_register_output(self, index, value):
+        if not (-32768 <= value <= 32767):
+            raise ValueError("Value must be between -32768 and 32767")
+        unsigned_val = value & 0xFFFF
+        self.server.data_bank.set_input_registers(self.ro_offset + index, [unsigned_val])

pyfactoryio-0.1.0.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: pyfactoryio
+Version: 0.1.0
+Summary: Factory IO Modbus Interface
+Author: Developer
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pyModbusTCP
+
+# PyFactoryIO
+
+PyFactoryIO is a Python library that provides a high-level, modular Modbus interface for interacting with [Factory I/O](https://factoryio.com/). It allows you to easily connect your Python control logic to Factory I/O simulations, abstracting away the low-level Modbus TCP communication and mapping digital/register inputs and outputs by name.
+
+## Features
+
+- **Easy Configuration:** Map Factory I/O sensors and actuators using descriptive names instead of Modbus addresses.
+- **Event-Driven & Loop-Based Execution:** Provides decorators to run callbacks on state changes, or a continuous control loop for cyclic execution.
+- **Auto-Mapping:** Automatically handles Modbus coils, discrete inputs, holding registers, and input registers.
+- **Lightweight:** Built on top of `pyModbusTCP`.
+
+## Installation
+
+You can install `pyfactoryio` directly via pip:
+
+```bash
+pip install pyfactoryio
+```
+
+## Quick Start
+
+### 1. Configure Factory I/O
+
+Ensure Factory I/O is configured to use the **Modbus TCP Server** driver. By default, PyFactoryIO listens on `127.0.0.1` port `5020`.
+
+### 2. Basic Example
+
+Here is a simple example demonstrating how to read a sensor and trigger an actuator.
+
+```python
+from pyfactoryio import FactoryIOServer
+
+# Define your input and output names in the order they appear in Factory I/O
+DI_NAMES = ["Sensor_1", "Start_Button"]
+DO_NAMES = ["Conveyor", "Warning_Light"]
+
+# Initialize the server
+server = FactoryIOServer(
+    di_names=DI_NAMES,
+    do_names=DO_NAMES
+)
+
+# Example 1: Event-driven callback
+@server.on_change("Start_Button")
+def on_start_pressed(value):
+    if value:
+        print("Start button pressed!")
+        server.Conveyor = True
+    else:
+        print("Start button released!")
+        server.Conveyor = False
+
+# Example 2: Continuous control loop
+def my_logic(srv):
+    # This function is called continuously by run_loop
+    if srv.Sensor_1:
+        srv.Warning_Light = True
+    else:
+        srv.Warning_Light = False
+
+if __name__ == "__main__":
+    # Start the event loop (e.g., at 10Hz)
+    server.run_loop(logic_func=my_logic, hz=10)
+```
+
+## Supported Variable Types
+
+- **di_names:** Digital Inputs (Sensors, Buttons) - Read from Factory I/O via Coils.
+- **do_names:** Digital Outputs (Conveyors, Lights) - Written to Factory I/O via Discrete Inputs.
+- **ri_names:** Register Inputs (Analog Sensors) - Read from Factory I/O via Holding Registers.
+- **ro_names:** Register Outputs (Analog Actuators) - Written to Factory I/O via Input Registers.
+
+## License
+
+This project is licensed under the MIT License.

pyfactoryio-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+pyfactoryio/__init__.py,sha256=7bSXSo4WPN_Vc7cTZZZvTAGck6eyvmz7QgzCgg73u0w,88
+pyfactoryio/gui.py,sha256=t6yNThBlyqkff5764EiZED_bSBSIJNunIh-NmneCHec,4000
+pyfactoryio/server.py,sha256=CoyZi4WNkR2xMCJ19-5WW_BzY7Y9eB-jSZjpAgnqR-w,5678
+pyfactoryio-0.1.0.dist-info/METADATA,sha256=SHgtpHJ-HKH7ohX1MdkBb033oYbJMaOwfgjCzARocp4,2915
+pyfactoryio-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyfactoryio-0.1.0.dist-info/top_level.txt,sha256=wHw13rUek7LEac6eHGzkNIwjclrUIpKhT7NuFSSNE6w,12
+pyfactoryio-0.1.0.dist-info/RECORD,,

pyfactoryio-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyfactoryio-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyfactoryio