moons-motor 0.0.1__tar.gz → 0.0.3__tar.gz

moons_motor-0.0.3/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012-2024 miroc99
+
+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.

{moons_motor-0.0.1 → moons_motor-0.0.3}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.1
 Name: moons_motor
-Version: 0.0.1
+Version: 0.0.3
 Summary: This is a python library for controlling the Moons' motor through the serial port.
-Author: miroc99
 Author-email: miroc <mike8503111@gmail.com>
 Project-URL: Repository, https://github.com/miroc99/moons_motor.git
 Classifier: Development Status :: 3 - Alpha
@@ -12,6 +11,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: pyserial
 Requires-Dist: rich
 Requires-Dist: python-socketio
@@ -27,4 +27,25 @@ Now only support Windows.
 Install through `pip`
 ```bash
 python -m pip install moons_motor
+
 ```
+## Usage
+```python
+from motor import MoonsStepper, StepperModules
+import simulate
+from time import sleep
+
+motor = MoonsStepper(StepperModules.STM17S_3RN, "0403", "6001", "TESTA")
+
+MoonsStepper.list_all_ports()
+motor.connect()
+
+motor.start_jog("", 10)
+sleep(5)
+motor.stop_jog()
+
+```
+## Tested Motor
+1. STM17S-3RN
+
+## Reference

moons_motor-0.0.3/README.md

@@ -0,0 +1,33 @@
+# Moons Motor
+
+This is a python library for control moons motor through serial port.
+
+## Compatibility
+Now only support Windows.
+
+## Installing
+Install through `pip`
+```bash
+python -m pip install moons_motor
+
+```
+## Usage
+```python
+from motor import MoonsStepper, StepperModules
+import simulate
+from time import sleep
+
+motor = MoonsStepper(StepperModules.STM17S_3RN, "0403", "6001", "TESTA")
+
+MoonsStepper.list_all_ports()
+motor.connect()
+
+motor.start_jog("", 10)
+sleep(5)
+motor.stop_jog()
+
+```
+## Tested Motor
+1. STM17S-3RN
+
+## Reference

moons_motor-0.0.3/moons_motor/Subject.py

@@ -0,0 +1,15 @@
+class Subject:
+    def __init__(self):
+        self._observers = []
+
+    def register(self, observer):
+        if observer not in self._observers:
+            self._observers.append(observer)
+
+    def unregister(self, observer):
+        if observer in self._observers:
+            self._observers.remove(observer)
+
+    def notify_observers(self, event):
+        for observer in self._observers:
+            observer.update(event)

moons_motor-0.0.3/moons_motor/__init__.py

@@ -0,0 +1,3 @@
+from moons_motor import *
+from status import *
+from simulate import *

moons_motor-0.0.3/moons_motor/example.py

@@ -0,0 +1,17 @@
+from motor import MoonsStepper, StepperModules
+import simulate
+from time import sleep
+
+motor = MoonsStepper(StepperModules.STM17S_3RN, "0403", "6001", "TESTA", False)
+
+simulate = simulate.moons_stepper_simulate(motor, 0, "http://localhost:3002")
+
+MoonsStepper.list_all_ports()
+motor.connect()
+simulate.connect()
+
+motor.start_jog("", 10)
+
+sleep(5)
+
+motor.stop_jog()

moons_motor-0.0.1/moons_motor/moons_motor.py → moons_motor-0.0.3/moons_motor/motor.py

@@ -1,102 +1,19 @@
 import serial
 from serial.tools import list_ports
 import re
-import time
 import threading
-import socketio
 from rich import print
 from rich.console import Console
 from rich.panel import Panel
 import queue
+from Subject import Subject
 
 
-class moons_stepper_status:
-    def __init__(self, address=""):
-
-        # info
-        self.address = ""
-        self.position = 0  # IP
-        self.temperature = 0  # IT
-        self.sensor_status = 0  # IS
-        self.voltage = 0  # IU
-        self.acceleration = 0  # AC
-        self.deceleration = 0  # DE
-        self.velocity = 0  # VE
-        self.distance = 0  # DI
-        self.jog_speed = 0  # JS
-
-        # status
-        self.status_string = ""
-        self.alarm = False
-        self.disabled = False
-        self.drive_fault = False
-        self.moving = False
-        self.homing = False
-        self.jogging = False
-        self.motion_in_progess = False
-        self.ready = False
-        self.stoping = False
-        self.waiting = False
-
-    def update_info(self, info: dict) -> bool:
-        if info is None or len(info) < 1:
-            print("Update failed: input is None")
-            return False
-        self.position = info["pos"]
-        self.temperature = info["temp"]
-        self.sensor_status = info["sensor"]
-        self.voltage = info["vol"]
-        self.acceleration = info["accel"]
-        self.deceleration = info["decel"]
-        self.velocity = info["vel"]
-        self.distance = info["dis"]
-        self.jog_speed = info["jogsp"]
-        return True
-
-    def update_status(self, status_string) -> bool:
-        if status_string == None and status_string == "":
-            print("Update failed: input is empty or None")
-            return False
-        self.status_string = status_string
-        self.alarm = "A" in status_string
-        self.disabled = "D" in status_string
-        self.drive_fault = "E" in status_string
-        self.moving = "F" in status_string
-        self.homing = "H" in status_string
-        self.jogging = "J" in status_string
-        self.motion_in_progess = "M" in status_string
-        self.ready = "R" in status_string
-        self.stoping = "S" in status_string
-        self.waiting = "T" in status_string
-        return True
-
-    def get_info(self) -> str:
-        return f"""
-        Position: {self.position}
-        Temperature: {self.temperature}
-        Sensor Status: {self.sensor_status}
-        Voltage: {self.voltage}
-        Acceleration: {self.acceleration}
-        Deceleration: {self.deceleration}
-        Velocity: {self.velocity}
-        Distance: {self.distance}
-        Jog Speed: {self.jog_speed}"""
-
-    def get_status(self) -> str:
-        return f"""
-        Alarm: {self.alarm}
-        Disabled: {self.disabled}
-        Drive Fault: {self.drive_fault}
-        Moving: {self.moving}
-        Homing: {self.homing}
-        Jogging: {self.jogging}
-        Motion in Progress: {self.motion_in_progess}
-        Ready: {self.ready}
-        Stoping: {self.stoping}
-        Waiting: {self.waiting}"""
-
-
-class moons_stepper:
+class StepperModules:
+    STM17S_3RN = "STM17S-3RN"
+
+
+class MoonsStepper(Subject):
     motorAdress = [
         "0",
         "1",
@@ -134,15 +51,14 @@ class moons_stepper:
 
     def __init__(
         self,
-        model,
+        model: StepperModules,
         VID,
         PID,
         SERIAL_NUM,
         only_simlate=False,
         universe=0,
-        simulate_ip="localhost",
-        simulate_port=3001,
     ):
+        super().__init__()
         self.universe = universe
         self.model = model
         self.only_simulate = only_simlate
@@ -163,11 +79,6 @@ class moons_stepper:
         self.sendQueue = queue.Queue()
         self.command_cache = queue.Queue()
         self.usedSendQueue = queue.Queue()
-        self.simulator = moons_stepper_simulate(
-            self,
-            universe=universe,
-            server_address=f"http://{simulate_ip}:{simulate_port}",
-        )
 
         self.console = Console()
 
@@ -190,12 +101,10 @@ class moons_stepper:
             14: 50000,
             15: 50800,
         }
-        self.simulator.connect()
 
     # region connection & main functions
     @staticmethod
     def list_all_ports():
-        # print("░░░░░░░░░░░░░░░░░░░ All COMPorts ░░░░░░░░░░░░░░░░░░░░░\n")
         ports = list(list_ports.comports())
         simple_ports = []
         port_info = ""
@@ -204,7 +113,6 @@ class moons_stepper:
             if p != ports[-1]:
                 port_info += "\n"
             simple_ports.append(p.description)
-        # print("\n░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░")
         print(Panel(port_info, title="All COMPorts"))
         return simple_ports
 
@@ -221,10 +129,10 @@ class moons_stepper:
             try:
                 self.ser = serial.Serial(COM, baudrate)
                 if self.ser is None:
-                    print("> Device not found")
+                    # print("> Device not found")
                     self.Opened = False
                 if self.ser.is_open:
-                    print(f"Device: {self.device} | COM: {COM} connected")
+                    # print(f"Device: {self.device} | COM: {COM} connected")
                     self.Opened = True
             except:
                 print("> Device error")
@@ -256,36 +164,15 @@ class moons_stepper:
                 if callback:
                     callback(self.device, self.Opened)
                     break
-                # try:
-                #     self.ser = serial.Serial(p.device, baudrate)
-                # except Exception as e:
-                #     print(f"Permission Error: {e}")
-                #     self.Opened = False
-                #     return
-
-                # self.listeningThread = threading.Thread(target=self.listening)
-                # self.sendingThread = threading.Thread(target=self.sending)
-                # self.listeningThread.daemon = True
-                # self.sendingThread.daemon = True
-                # self.listeningThread.start()
-                # self.sendingThread.start()
-
                 break
 
             if self.only_simulate:
                 self.device = "Simulate"
                 self.Opened = True
-            if not self.Opened:
-                print("> Device not found")
-                if callback:
-                    callback(self.device, self.Opened)
-                # self.sendingThread = threading.Thread(target=self.sending)
-                # self.sendingThread.daemon = True
-                # self.sendingThread.start()
-        # self.device = "Target device"
-        # if self.ser is None and not self.only_simlate:
-        #     print("> Device not found")
-        #     self.Opened = False
+        if not self.Opened:
+            print("> Device not found")
+            if callback:
+                callback(self.device, self.Opened)
 
     def disconnect(self):
         if self.only_simulate:
@@ -300,15 +187,10 @@ class moons_stepper:
             self.Opened = False
             self.ser.flush()
             self.ser.close()
-            # if self.device is not None:
-            #     print("{} Disconnected".format(self.device))
-            # else:
             print(f"{self.device} Disconnected")
 
     def send(self, command, eol=b"\r"):
         if (self.ser != None and self.ser.is_open) or self.only_simulate:
-            # self.sendQueue.put(command + "\r")
-            # self.temp_cmd = self.sendQueue.get()
             self.temp_cmd = command + "\r"
 
             if "~" in self.temp_cmd:
@@ -316,90 +198,15 @@ class moons_stepper:
                 self.temp_cmd = self.temp_cmd[1:]
             else:
                 self.usedSendQueue.put(self.temp_cmd)
-                # self.command_cache.put(self.temp_cmd)
             if self.ser is not None or not self.only_simulate:
                 self.ser.write(self.temp_cmd.encode("ascii"))
             if self.is_log_message:
                 print(
                     f"[bold green]Send to {self.device}:[/bold green] {self.temp_cmd}"
                 )
-            self.simulator.emit("motor", f"{self.universe}-{self.temp_cmd}")
+            super().notify_observers(f"{self.universe}-{self.temp_cmd}")
         else:
-            print(f"{self.device} is not open")
-
-    def sending(self):
-        self.is_sending = True
-        print("Sending thread started")
-        # start_time = time.time()
-        try:
-            while self.is_sending:
-                # start_time = time.time()
-                if self.sendQueue.empty():
-                    continue
-                # self.temp_cmd = ""
-                self.temp_cmd = self.sendQueue.get_nowait()
-
-                if "~" in self.temp_cmd:
-                    # remove ~ in self.temp_cmd
-                    self.temp_cmd = self.temp_cmd[1:]
-                else:
-                    self.usedSendQueue.put(self.temp_cmd)
-                # self.command_cache.put(self.temp_cmd)
-
-                if self.ser is not None and self.ser.is_open is not self.only_simulate:
-                    self.ser.write(self.temp_cmd.encode("ascii"))
-                # print(
-                #     f"[bold green]Send to {self.device}:[/bold green] {self.temp_cmd}"
-                # )
-                # self.simulate.emit("motor", f"{self.universe}-{self.temp_cmd}")
-                # print(f"[bold yellow]Cache:[/bold yellow]{self.temp_cmd}")
-
-                self.sendQueue.task_done()
-
-                time.sleep(0.05)
-
-        except Exception as e:
-            print("Error in sending thread:")
-            print(e)
-            self.is_sending = False
-
-    def listening(self):
-        self.listen = True
-        self.listeningBuffer = ""
-        print("Listening thread started")
-        # start_time = time.time()
-        try:
-            while True:
-                # start_time = time.time()
-                if not self.listen:
-                    break
-                if self.only_simulate:
-                    continue
-                if self.ser is not None and self.ser.is_open:
-                    if self.ser.in_waiting > 0:
-                        self.listeningBuffer += self.ser.read(1).decode(
-                            "utf-8", "replace"
-                        )
-                        if self.listeningBuffer.endswith("\r"):
-                            self.recvQueue.put(self.listeningBuffer)
-                            self.listeningBuffer = ""
-                else:
-                    print(f"{self.device} is not open")
-                if not self.recvQueue.empty():
-                    self.temp_recv = self.recvQueue.get()
-                    self.temp_used_cmd = self.usedSendQueue.get()
-                    print(
-                        f"[bold green]Recv:[/bold green] {self.temp_used_cmd}->{self.temp_recv}"
-                    )
-                    self.recvQueue.task_done()
-                    self.usedSendQueue.task_done()
-                time.sleep(0.05)
-                # print(f"Time: {time.time()-start_time}")
-        except Exception as e:
-            print("Error in listening thread:")
-            print(e)
-            self.listen = False
-        print("Listening thread stopped")
+            print(f"Target device is not opened. Command: {command}")
 
     # endregion
 
@@ -409,22 +216,14 @@ class moons_stepper:
         self.send(self.addressed_cmd(motor_address, cmd))
 
     def move_absolute(self, motor_address="", position=0, speed=0.15):
-        # if speed > 0:
-        #     self.set_velocity(motor_address, speed)
         self.send(self.addressed_cmd(motor_address, f"VE{speed}"))
         self.send(self.addressed_cmd(motor_address, f"FP{position}"))
 
     def move_fixed_distance(self, motor_address="", distance=100, speed=0.15):
-        # if speed > 0:
-        #     self.set_velocity(motor_address, speed)
         self.send(self.addressed_cmd(motor_address, "VE{}".format(speed)))
         self.send(self.addressed_cmd(motor_address, "FL{}".format(int(distance))))
 
     def start_jog(self, motor_address="", speed=0.15, direction="CW"):
-        # if direction == "CW":
-        #     self.send(self.addressed_cmd(motor_address, "DI1"))
-        # if direction == "CCW":
-        #     self.send(self.addressed_cmd(motor_address, "DI-1"))
         self.send(self.addressed_cmd(motor_address, "JS{}".format(speed)))
         self.send(self.addressed_cmd(motor_address, "CJ"))
 
@@ -449,18 +248,12 @@ class moons_stepper:
     def setup_motor(self, motor_address="", kill=False):
         if kill:
             self.stop_and_kill(motor_address)
-        # time.sleep(1)
         self.set_transmit_delay(motor_address, 25)
         self.set_return_format_dexcimal(motor_address)
-        # self.motor_wait(motor_address, 0.1)
-        # status = self.get_status(motor_address)
 
     def calibrate(self, motor_address="", speed=0.3, onStart=None, onComplete=None):
         self.send(self.addressed_cmd(motor_address, "VE{}".format(speed)))
-        # self.send(self.addressed_cmd(motor_address, "WT0.2"))
         self.send(self.addressed_cmd(motor_address, "DI10"))
-        # time.sleep(self.transmitDelay)
-        # self.send(self.addressed_cmd(motor_address, "FS3F"))
         self.send(self.addressed_cmd(motor_address, "SH3F"))
         self.send(self.addressed_cmd(motor_address, "EP0"))
         self.send(self.addressed_cmd(motor_address, "SP0"))
@@ -470,6 +263,7 @@ class moons_stepper:
         self.send(self.addressed_cmd(motor_address, "TD{}".format(delay)))
 
     # endregion
+
     # region motor status functions
     def get_position(self, motor_address):
         self.send(self.addressed_cmd(motor_address, "IP"))
@@ -577,69 +371,6 @@ class moons_stepper:
             return "No_value_found"
 
 
-class moons_stepper_simulate:
-    def __init__(
-        self,
-        moons_motor: moons_stepper,
-        universe: int = 0,
-        server_address: str = "http://localhost:3001",
-    ):
-        self.server_address = server_address
-        self.universe = universe
-        self.moons_motor = moons_motor
-        self.io = socketio.SimpleClient()
-        self.connected = False
-        self.is_log_message = True
-
-    def connect(self):
-        try:
-            self.is_log_message = False
-            self.io.connect(self.server_address)
-            self.connected = True
-            print(f"Socket connected to {self.server_address}[{self.io.sid}]")
-            # self.rederict_thread = threading.Thread(
-            #     target=self.rederict_job,
-            # )
-            # self.rederict_thread.daemon = True
-            # self.rederict_thread.start()
-        except Exception as e:
-            print(f"Socket connection error: {e}")
-            self.connected = False
-
-    def rederict_job(self):
-        if not self.connected:
-            print("Socket not connected")
-            return
-        if self.moons_motor is None:
-            print("Motor is None")
-            return
-        while True:
-            # self.moons_motor.on_send_event.wait(timeout=0.5)
-            if self.moons_motor.command_cache.empty():
-                continue
-            cmd = self.moons_motor.command_cache.get_nowait()
-            # self.moons_motor.command_cache.task_done()
-
-            self.emit("motor", f"{self.universe}-{cmd}")
-            # self.moons_motor.command_cache = ""
-            # self.moons_motor.on_send_event.clear()
-
-            if not self.connected:
-                break
-            time.sleep(0.05)
-
-    def disconnect(self):
-        self.io.disconnect()
-
-    def emit(self, eventName: str, data):
-        if not self.connected:
-            print("Socket not connected")
-            return
-        self.io.emit(eventName, data)
-        if self.is_log_message:
-            print("[bold blue]Send to socket:[/bold blue] {}\n".format(data))
-
-
 # endregion
 
 # SERIAL => 上次已知父系(尾巴+A) 或是事件分頁

moons_motor-0.0.3/moons_motor/observer.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+@abstractmethod
+class Observer(ABC):
+    def update(self, event):
+        pass

moons_motor-0.0.3/moons_motor/simulate.py

@@ -0,0 +1,74 @@
+import socketio
+import motor
+from observer import Observer
+import time
+
+
+class moons_stepper_simulate(Observer):
+    def __init__(
+        self,
+        moons_motor: motor.MoonsStepper,
+        universe: int = 0,
+        server_address: str = "http://localhost:3001",
+    ):
+        self.server_address = server_address
+        self.universe = universe
+        self.moons_motor = moons_motor
+        self.io = socketio.SimpleClient()
+        self.connected = False
+        self.is_log_message = True
+
+    def update(self, event):
+        print(f"Simulate send: {event}")
+        self.emit("motor", event)
+
+    def connect(self):
+        self.moons_motor.register(self)
+        try:
+            self.is_log_message = False
+            self.io.connect(self.server_address)
+            self.connected = True
+            print(f"Socket connected to {self.server_address}[{self.io.sid}]")
+            # self.rederict_thread = threading.Thread(
+            #     target=self.rederict_job,
+            # )
+            # self.rederict_thread.daemon = True
+            # self.rederict_thread.start()
+        except Exception as e:
+            print(f"Socket connection error: {e}")
+            self.connected = False
+
+    def rederict_job(self):
+        if not self.connected:
+            print("Socket not connected")
+            return
+        if self.moons_motor is None:
+            print("Motor is None")
+            return
+        while True:
+            # self.moons_motor.on_send_event.wait(timeout=0.5)
+            if self.moons_motor.command_cache.empty():
+                continue
+            cmd = self.moons_motor.command_cache.get_nowait()
+            # self.moons_motor.command_cache.task_done()
+
+            self.emit("motor", f"{self.universe}-{cmd}")
+            # self.moons_motor.command_cache = ""
+            # self.moons_motor.on_send_event.clear()
+
+            if not self.connected:
+                break
+            time.sleep(0.05)
+
+    def disconnect(self):
+        self.connected = False
+        self.moons_motor.unregister(self)
+        self.io.disconnect()
+
+    def emit(self, eventName: str, data):
+        if not self.connected:
+            print("Socket not connected")
+            return
+        self.io.emit(eventName, data)
+        if self.is_log_message:
+            print("[bold blue]Send to socket:[/bold blue] {}\n".format(data))

moons_motor-0.0.3/moons_motor/status.py

@@ -0,0 +1,84 @@
+class MoonsStepperStatus:
+    def __init__(self, address=""):
+
+        # info
+        self.address = ""
+        self.position = 0  # IP
+        self.temperature = 0  # IT
+        self.sensor_status = 0  # IS
+        self.voltage = 0  # IU
+        self.acceleration = 0  # AC
+        self.deceleration = 0  # DE
+        self.velocity = 0  # VE
+        self.distance = 0  # DI
+        self.jog_speed = 0  # JS
+
+        # status
+        self.status_string = ""
+        self.alarm = False
+        self.disabled = False
+        self.drive_fault = False
+        self.moving = False
+        self.homing = False
+        self.jogging = False
+        self.motion_in_progess = False
+        self.ready = False
+        self.stoping = False
+        self.waiting = False
+
+    def update_info(self, info: dict) -> bool:
+        if info is None or len(info) < 1:
+            print("Update failed: input is None")
+            return False
+        self.position = info["pos"]
+        self.temperature = info["temp"]
+        self.sensor_status = info["sensor"]
+        self.voltage = info["vol"]
+        self.acceleration = info["accel"]
+        self.deceleration = info["decel"]
+        self.velocity = info["vel"]
+        self.distance = info["dis"]
+        self.jog_speed = info["jogsp"]
+        return True
+
+    def update_status(self, status_string) -> bool:
+        if status_string == None and status_string == "":
+            print("Update failed: input is empty or None")
+            return False
+        self.status_string = status_string
+        self.alarm = "A" in status_string
+        self.disabled = "D" in status_string
+        self.drive_fault = "E" in status_string
+        self.moving = "F" in status_string
+        self.homing = "H" in status_string
+        self.jogging = "J" in status_string
+        self.motion_in_progess = "M" in status_string
+        self.ready = "R" in status_string
+        self.stoping = "S" in status_string
+        self.waiting = "T" in status_string
+        return True
+
+    def get_info(self) -> str:
+        return f"""
+        Position: {self.position}
+        Temperature: {self.temperature}
+        Sensor Status: {self.sensor_status}
+        Voltage: {self.voltage}
+        Acceleration: {self.acceleration}
+        Deceleration: {self.deceleration}
+        Velocity: {self.velocity}
+        Distance: {self.distance}
+        Jog Speed: {self.jog_speed}"""
+
+    def get_status(self) -> str:
+        return f"""
+        Alarm: {self.alarm}
+        Disabled: {self.disabled}
+        Drive Fault: {self.drive_fault}
+        Moving: {self.moving}
+        Homing: {self.homing}
+        Jogging: {self.jogging}
+        Motion in Progress: {self.motion_in_progess}
+        Ready: {self.ready}
+        Stoping: {self.stoping}
+        Waiting: {self.waiting}"""

{moons_motor-0.0.1 → moons_motor-0.0.3}/moons_motor.egg-info/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.1
 Name: moons_motor
-Version: 0.0.1
+Version: 0.0.3
 Summary: This is a python library for controlling the Moons' motor through the serial port.
-Author: miroc99
 Author-email: miroc <mike8503111@gmail.com>
 Project-URL: Repository, https://github.com/miroc99/moons_motor.git
 Classifier: Development Status :: 3 - Alpha
@@ -12,6 +11,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: pyserial
 Requires-Dist: rich
 Requires-Dist: python-socketio
@@ -27,4 +27,25 @@ Now only support Windows.
 Install through `pip`
 ```bash
 python -m pip install moons_motor
+
 ```
+## Usage
+```python
+from motor import MoonsStepper, StepperModules
+import simulate
+from time import sleep
+
+motor = MoonsStepper(StepperModules.STM17S_3RN, "0403", "6001", "TESTA")
+
+MoonsStepper.list_all_ports()
+motor.connect()
+
+motor.start_jog("", 10)
+sleep(5)
+motor.stop_jog()
+
+```
+## Tested Motor
+1. STM17S-3RN
+
+## Reference

{moons_motor-0.0.1 → moons_motor-0.0.3}/moons_motor.egg-info/SOURCES.txt

@@ -1,8 +1,14 @@
+LICENSE
 README.md
 pyproject.toml
 setup.py
+moons_motor/Subject.py
 moons_motor/__init__.py
-moons_motor/moons_motor.py
+moons_motor/example.py
+moons_motor/motor.py
+moons_motor/observer.py
+moons_motor/simulate.py
+moons_motor/status.py
 moons_motor.egg-info/PKG-INFO
 moons_motor.egg-info/SOURCES.txt
 moons_motor.egg-info/dependency_links.txt

{moons_motor-0.0.1 → moons_motor-0.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "moons_motor"
-version = "0.0.1"
+version = "0.0.3"
 authors = [{ name = "miroc", email = "mike8503111@gmail.com" }]
 description = "This is a python library for controlling the Moons' motor through the serial port."
 readme = "README.md"

moons_motor-0.0.3/setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup, find_packages
+
+setup()

moons_motor-0.0.1/README.md

@@ -1,12 +0,0 @@
-# Moons Motor
-
-This is a python library for control moons motor through serial port.
-
-## Compatibility
-Now only support Windows.
-
-## Installing
-Install through `pip`
-```bash
-python -m pip install moons_motor
-```

moons_motor-0.0.1/moons_motor/__init__.py

@@ -1 +0,0 @@
-from moons_motor import *

moons_motor-0.0.1/setup.py

@@ -1,10 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name="moons_motor",
-    version="0.0.1",
-    description="A simple motor control library for the Moons stepper motor driver",
-    author="miroc99",
-    packages=find_packages(),
-    install_requires=["pyserial", "rich", "python-socketio"],
-)