moons-motor 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

moons_motor/motor.py

@@ -1,4 +1,5 @@
 import serial
+import serial.rs485
 from serial.tools import list_ports
 import re
 import threading
@@ -51,6 +52,7 @@ class StepperCommand:
     SET_RETURN_FORMAT_HEXADECIMAL: str = "IFH"  # Set return format to hexadecimal
 
     SET_TRANSMIT_DELAY: str = "TD"  # Set transmit delay
+    REQUEST_STATUS: str = "RS"  # Request status
 
 
 class MoonsStepper(Subject):
@@ -110,9 +112,10 @@ class MoonsStepper(Subject):
         self.Opened = False
         self.recvQueue = queue.Queue()
         self.sendQueue = queue.Queue()
-        self.pending_callbacks = {}
+        self.pending_callbacks = queue.Queue()
         self.update_thread = None
         self.is_updating = False
+        self.readBuffer = ""
 
         self.console = Console()
 
@@ -183,7 +186,22 @@ class MoonsStepper(Subject):
 
         def attempt_connect(COM, baudrate):
             try:
-                self.ser = serial.Serial(port=COM, baudrate=baudrate)
+                # self.ser = serial.Serial(
+                #     port=COM,
+                #     baudrate=baudrate,
+                #     bytesize=serial.EIGHTBITS,
+                #     parity=serial.PARITY_NONE,
+                #     stopbits=serial.STOPBITS_ONE,
+                #     timeout=0.5,
+                # )
+                self.ser = serial.rs485.RS485(port=COM, baudrate=baudrate)
+                self.ser.rs485_mode = serial.rs485.RS485Settings(
+                    rts_level_for_tx=True,
+                    rts_level_for_rx=False,
+                    loopback=False,
+                    delay_before_tx=0.02,
+                    delay_before_rx=0.02,
+                )
                 if self.ser is None:
                     self.Opened = False
                 if self.ser.is_open:
@@ -236,6 +254,8 @@ class MoonsStepper(Subject):
                 callback(self.device, self.Opened)
 
     def disconnect(self):
+        self.send_command(command=StepperCommand.STOP_KILL)
+        time.sleep(0.5)
         self.sendQueue.queue.clear()
         self.recvQueue.queue.clear()
         self.is_updating = False
@@ -259,7 +279,6 @@ class MoonsStepper(Subject):
             self.temp_cmd = command + "\r"
 
             if self.ser is not None or not self.only_simulate:
-                self.temp_cmd += "\r"
                 self.ser.write(self.temp_cmd.encode("ascii"))
             if self.is_log_message:
                 print(
@@ -287,20 +306,28 @@ class MoonsStepper(Subject):
                 if self.ser.in_waiting > 0:
                     response = self.ser.read(self.ser.in_waiting)
                     response = response.decode("ascii", errors="ignore").strip()
-                    self.handle_recv(response)
-                    time.sleep(0.01)  # Send delay
+                    response = response.split("\r")
+
+                    for r in response:
+                        if r != "":
+                            self.readBuffer += r
+                            self.handle_recv(r)
+
             if self.sendQueue.empty() != True:
+                # time.sleep(
+                #     0.02
+                # )  # Time for RS485 converter to switch between Transmit and Receive mode
                 while not self.sendQueue.empty():
+                    # time.sleep(
+                    #     0.05
+                    # )  # Time for RS485 converter to switch between Transmit and Receive mode
                     cmd = self.sendQueue.get_nowait()
                     self.send(cmd)
                     self.sendQueue.task_done()
-                time.sleep(
-                    0.01
-                )  # Time for RS485 converter to switch between Transmit and Receive mode
 
     def handle_recv(self, response):
         if "*" in response:
-            print("buffered_ack")
+            print(f"[bold green](o)buffered_ack[/bold green]")
         elif "%" in response:
             print(f"[bold green](v)success_ack[/bold green]")
         elif "?" in response:
@@ -309,24 +336,54 @@ class MoonsStepper(Subject):
             print(f"[bold blue]Received from {self.device}: [/bold blue]", response)
             self.recvQueue.put_nowait(response)
 
-            for command, callback in list(self.pending_callbacks.items()):
-                if command in response:
-                    if callback:
-                        callback(response)
-                    del self.pending_callbacks[command]
-                    break
+            if "=" in response:
+                callback = self.pending_callbacks.get_nowait()
+                if callback:
+                    callback(response)
+            # for command, callback in list(self.pending_callbacks.items()):
+            #     if command in response:
+            #         if callback:
+            #             callback(response)
+            #         del self.pending_callbacks[command]
+            #         break
 
     # endregion
 
     # region motor motion functions
 
-    def setup_motor(self, motor_address="", kill=False):
-        if kill:
-            self.stop_and_kill(motor_address)
-        self.set_transmit_delay(motor_address, 25)
-        self.set_return_format_dexcimal(motor_address)
+    # def setup_motor(self, motor_address="", kill=False):
+    #     if kill:
+    #         self.stop_and_kill(motor_address)
+    #     self.set_transmit_delay(motor_address, 25)
+    #     self.set_return_format_dexcimal(motor_address)
 
     def home(self, motor_address="", speed=0.3, onComplete=None):
+        homing_complete = threading.Event()  # Shared event to signal completion
+
+        def check_status(response):
+            result = MoonsStepper.process_response(response)
+            print(f"[bold blue]Status check result:[/bold blue] {result}")
+            if "H" not in result["value"]:
+                print("[bold green]Motor is homed.[/bold green]")
+                if onComplete:  # Call the onComplete callback if provided
+                    onComplete(result)
+                homing_complete.set()  # Signal that homing is complete
+            else:
+                print("[bold yellow]Motor is not homed yet.[/bold yellow]")
+
+        def check_homing_complete():
+            while not homing_complete.is_set():  # Loop until homing is complete
+                self.get_status(
+                    motor_address=motor_address,
+                    command=StepperCommand.REQUEST_STATUS,
+                    callback=check_status,
+                )
+                time.sleep(0.3)
+
+        home_thread = threading.Thread(
+            target=check_homing_complete,
+            daemon=True,
+        )
         self.send_command(
             address=motor_address, command=StepperCommand.VELOCITY, value=speed
         )
@@ -334,23 +391,47 @@ class MoonsStepper(Subject):
             address=motor_address, command=StepperCommand.HOME, value="3F"
         )
         self.send_command(
-            address=motor_address, command=StepperCommand.ENCODER_POSITION
+            address=motor_address, command=StepperCommand.ENCODER_POSITION, value=0
         )
         self.send_command(
             address=motor_address, command=StepperCommand.SET_POSITION, value=0
         )
-        if onComplete:
-            self.get_status(
-                motor_address, StepperCommand.SET_POSITION, callback=onComplete
-            )
+        home_thread.start()
 
     # endregion
     def get_status(self, motor_address, command: StepperCommand, callback=None):
         command = self.addressed_cmd(motor_address, command)
         if callback:
-            self.pending_callbacks[command] = callback
+            self.pending_callbacks.put_nowait(callback)
         self.sendQueue.put_nowait(command)
 
+    def decode_status(status_code):
+        """
+        Decode the status code from the motor.
+        """
+        status = {
+            "A": "An Alarm code is present (use AL command to see code, AR command to clear code)",
+            "D": "Disabled (the drive is disabled)",
+            "E": "Drive Fault (drive must be reset by AR command to clear this fault)",
+            "F": "Motor moving",
+            "H": "Homing (SH in progress)",
+            "J": "Jogging (CJ in progress)",
+            "M": "Motion in progress (Feed & Jog Commands)",
+            "P": "In position",
+            "R": "Ready (Drive is enabled and ready)",
+            "S": "Stopping a motion (ST or SK command executing)",
+            "T": "Wait Time (WT command executing)",
+            "W": "Wait Input (WI command executing)",
+        }
+        status_string = ""
+        for char in status_code:
+            if char in status:
+                status_string += status[char]
+                status_string += "\n"
+            else:
+                status_string += f"Unknown status code: {char}"
+        return status_string
+
     # endregion
 
     # region utility functions

{moons_motor-0.1.2.dist-info → moons_motor-0.1.4.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: moons_motor
-Version: 0.1.2
+Version: 0.1.4
 Summary: This is a python library for controlling the Moons' motor through the serial port.
 Author-email: miroc <mike8503111@gmail.com>
 Project-URL: Repository, https://github.com/miroc99/moons_motor.git
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Terminals :: Serial
 Classifier: License :: OSI Approved :: MIT License
@@ -38,7 +38,7 @@ python -m pip install moons_motor
 ## Usage
 
 ```python
-from motor import MoonsStepper, StepperModules
+from motor import MoonsStepper, StepperModules, StepperCommand
 import simulate
 from time import sleep
 
@@ -47,9 +47,9 @@ motor = MoonsStepper(StepperModules.STM17S_3RN, "0403", "6001", "TESTA")
 MoonsStepper.list_all_ports()
 motor.connect()
 
-motor.start_jog("", 10)
+motor.send_command(address="@", command=StepperCommand.JOG)
 sleep(5)
-motor.stop_jog()
+motor.send_command(address="@", command=StepperCommand.STOP_JOG)
 
 ```
 

{moons_motor-0.1.2.dist-info → moons_motor-0.1.4.dist-info}/RECORD

@@ -1,11 +1,11 @@
 moons_motor/__init__.py,sha256=qOpsRwizV-DpKSvNzyvj8ju3cs6vwgIICur1Oe6sxOA,27
-moons_motor/motor.py,sha256=fiaKLb9NC3uf5rgBHBmQM2M2DzGw_wLu_eo9keTvkXY,12044
+moons_motor/motor.py,sha256=ZXXX6Ie-PL5QN8O-JpMVGh9xgYSsQpJM0BsqiVbtdns,15521
 moons_motor/observer.py,sha256=PXzuPYKRb2HpjArJcD8HakYIPfFGAs1uBDIL8PSizgA,124
 moons_motor/simulate.py,sha256=J0y1fZhoOim9i-BAkprxnPern1SAdkDfKPqT2MWyDwU,2561
 moons_motor/status.py,sha256=jXQZFZTt9ugHktkWKLII8MpEQQaeO-UjlwTrrP4LJNE,2872
 moons_motor/subject.py,sha256=L_GS6fvJTeX7X23o3T92oiZ4rtLVKA2OEd9GpHn_Dz4,445
-moons_motor-0.1.2.dist-info/licenses/LICENSE,sha256=nsYjO800SjIjI85y2kVHR5mC3tca2vs4kK_BhNe89bM,1074
-moons_motor-0.1.2.dist-info/METADATA,sha256=LYi8aOV7Ft14G-SIPo4IDdsclgtmKDbfQJDst7X6uh8,1304
-moons_motor-0.1.2.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-moons_motor-0.1.2.dist-info/top_level.txt,sha256=0dE-CR5_NYBw34jHIDGQNWpMllzO6mtUIuKyRv_rJLg,12
-moons_motor-0.1.2.dist-info/RECORD,,
+moons_motor-0.1.4.dist-info/licenses/LICENSE,sha256=nsYjO800SjIjI85y2kVHR5mC3tca2vs4kK_BhNe89bM,1074
+moons_motor-0.1.4.dist-info/METADATA,sha256=OfYNsukji4MOjMxTBk87GHo1Y4GH5eQFkfpLY8czulE,1403
+moons_motor-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+moons_motor-0.1.4.dist-info/top_level.txt,sha256=0dE-CR5_NYBw34jHIDGQNWpMllzO6mtUIuKyRv_rJLg,12
+moons_motor-0.1.4.dist-info/RECORD,,

{moons_motor-0.1.2.dist-info → moons_motor-0.1.4.dist-info}/WHEEL

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