moons-motor 0.0.11__py3-none-any.whl → 0.1.3__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
@@ -8,12 +9,51 @@ from rich.panel import Panel
 import queue
 from moons_motor.subject import Subject
 import time
+import threading
+
+from dataclasses import dataclass
 
 
 class StepperModules:
     STM17S_3RN = "STM17S-3RN"
 
 
+@dataclass(frozen=True)
+class StepperCommand:
+    JOG: str = "CJ"  # Start jogging
+    JOG_SPEED: str = "JS"  # Jogging speed (Need to set before start jogging)
+    CHANGE_JOG_SPEED: str = "CS"  # Change jogging speed while jogging
+    STOP_JOG: str = "SJ"  # Stop jogging with deceleration
+    STOP: str = "ST"  # Stop immediately (No deceleration)
+    STOP_DECEL: str = "STD"  # Stop with deceleration
+    STOP_KILL: str = (
+        "SK"  # Stop with deceleration(Control by AM) and kill all unexecuted commands
+    )
+    STOP_KILL_DECEL: str = (
+        "SKD"  # Stop and kill all unexecuted commands with deceleration(Control by DE)
+    )
+    ENABLE: str = "ME"  # Enable motor
+    DISABLE: str = "MD"  # Disable motor
+    MOVE_ABSOLUTE: str = "FP"  # Move to absolute position
+    MOVE_FIXED_DISTANCE: str = "FL"  # Move to fixed distance
+    POSITION: str = "IP"  # Motor absolute position(Calculated trajectory position)
+    TEMPERATURE: str = "IT"  # Motor temperature
+    VOLTAGE: str = "IU"  # Motor voltage
+
+    ENCODER_POSITION: str = "EP"  # Encoder position
+    SET_POSITION: str = "SP"  # Set encoder position
+
+    HOME: str = "SH"  # Home position
+    VELOCITY: str = "VE"  # Set velocity
+
+    ALARM_RESET: str = "AR"  # Reset alarm
+
+    SET_RETURN_FORMAT_DECIMAL: str = "IFD"  # Set return format to decimal
+    SET_RETURN_FORMAT_HEXADECIMAL: str = "IFH"  # Set return format to hexadecimal
+
+    SET_TRANSMIT_DELAY: str = "TD"  # Set transmit delay
+
+
 class MoonsStepper(Subject):
     motorAdress = [
         "0",
@@ -61,25 +101,20 @@ class MoonsStepper(Subject):
     ):
         super().__init__()
         self.universe = universe
-        self.model = model
+        self.model = model  # Motor model
         self.only_simulate = only_simlate
-        self.device = ""
+        self.device = ""  # COM port description
         self.VID = VID
         self.PID = PID
-        self.SERIAL_NUM = SERIAL_NUM
+        self.SERIAL_NUM = SERIAL_NUM  # ID for determent the deivice had same VID and PID, can be config using chips manufacturer tool
         self.ser = None
-        self.listeningBuffer = ""
-        self.listeningBufferPre = ""
-        self.transmitDelay = 0.010
-        self.lock = False
         self.Opened = False
-        self.new_data_event = threading.Event()
-        self.new_value_event = threading.Event()
-        self.on_send_event = threading.Event()
         self.recvQueue = queue.Queue()
         self.sendQueue = queue.Queue()
-        self.command_cache = queue.Queue()
-        self.usedSendQueue = queue.Queue()
+        self.pending_callbacks = queue.Queue()
+        self.update_thread = None
+        self.is_updating = False
+        self.readBuffer = ""
 
         self.console = Console()
 
@@ -117,7 +152,29 @@ class MoonsStepper(Subject):
         print(Panel(port_info, title="All COMPorts"))
         return simple_ports
 
+    @staticmethod
+    def process_response(response):
+        equal_sign_index = response.index("=")
+        address = response[0]
+        command = response[1:equal_sign_index]
+        value = response[equal_sign_index + 1 :]
+
+        if command == "IT" or command == "IU":
+            # Handle temperature response
+            value = int(value) / 10.0
+        return {
+            "address": address,
+            "command": command,
+            "value": value,
+        }
+
+    def __start_update_thread(self):
+        self.update_thread = threading.Thread(target=self.update, daemon=True)
+        self.is_updating = True
+        self.update_thread.start()
+
     def connect(self, COM=None, baudrate=9600, callback=None):
+        # Simulate mode
         if self.only_simulate:
             self.Opened = True
             self.device = f"Simulate-{self.universe}"
@@ -128,57 +185,80 @@ class MoonsStepper(Subject):
 
         def attempt_connect(COM, baudrate):
             try:
-                self.ser = serial.Serial(COM, 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:
-                    # print("> Device not found")
                     self.Opened = False
                 if self.ser.is_open:
-                    # print(f"Device: {self.device} | COM: {COM} connected")
                     self.Opened = True
-            except:
-                print("> Device error")
+                    print(f"[bold green]Device connected[/bold green]: {self.device}")
+
+            except Exception as e:
+                print(f"[bold red]Device error:[/bold red] {e} ")
                 self.Opened = False
 
+        ports = list(list_ports.comports())
         if COM is not None and not self.only_simulate:
             attempt_connect(COM, baudrate)
             if callback:
                 callback(self.device, self.Opened)
-            return
-        ports = list(list_ports.comports())
-        for p in ports:
-            m = re.match(
-                r"USB\s*VID:PID=(\w+):(\w+)\s*SER=([A-Za-z0-9]*)", p.usb_info()
-            )
-            print(m, p.usb_info())
-            if (
-                m
-                and m.group(1) == self.VID
-                and m.group(2) == self.PID
-                # and m.group(3) == self.SERIAL_NUM
-            ):
-                print("find vid pid match")
-                if m.group(3) == self.SERIAL_NUM or self.SERIAL_NUM == "":
-                    print(
-                        f"Device: {p.description} | VID: {m.group(1)} | PID: {m.group(2)} | SER: {m.group(3)} connected"
-                    )
-
-                    self.device = p.description
-
-                    attempt_connect(p.device, baudrate)
-                    if callback:
-                        callback(self.device, self.Opened)
+        else:
+            for p in ports:
+                m = re.match(
+                    r"USB\s*VID:PID=(\w+):(\w+)\s*SER=([A-Za-z0-9]*)", p.usb_info()
+                )
+                print(p.usb_info())
+                if (
+                    m
+                    and m.group(1) == self.VID
+                    and m.group(2) == self.PID
+                    # and m.group(3) == self.SERIAL_NUM
+                ):
+                    if m.group(3) == self.SERIAL_NUM or self.SERIAL_NUM == "":
+                        print(
+                            f"[bold yellow]Device founded:[/bold yellow] {p.description} | VID: {m.group(1)} | PID: {m.group(2)} | SER: {m.group(3)}"
+                        )
+
+                        self.device = p.description
+
+                        attempt_connect(p.device, baudrate)
+
                         break
-                    break
 
-            if self.only_simulate:
-                self.device = "Simulate"
-                self.Opened = True
+                if self.only_simulate:
+                    self.device = "Simulate"
+                    self.Opened = True
+        time.sleep(0.5)
+        self.__start_update_thread()
+        if callback:
+            callback(self.device, self.Opened)
+
         if not self.Opened:
-            print("> Device not found")
+            print(f"[bold red]Device not found[/bold red]")
             if callback:
                 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
+        self.update_thread = None
         if self.only_simulate:
             self.listen = False
             self.is_sending = False
@@ -191,19 +271,13 @@ class MoonsStepper(Subject):
             self.Opened = False
             self.ser.flush()
             self.ser.close()
-            print(f"{self.device} Disconnected")
+            print(f"[bold red]Device disconnected[/bold red]: {self.device}")
 
     def send(self, command, eol=b"\r"):
         if (self.ser != None and self.ser.is_open) or self.only_simulate:
             self.temp_cmd = command + "\r"
 
-            if "~" in self.temp_cmd:
-                # remove ~ in self.temp_cmd
-                self.temp_cmd = self.temp_cmd[1:]
-            else:
-                self.usedSendQueue.put(self.temp_cmd)
             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(
@@ -213,249 +287,107 @@ class MoonsStepper(Subject):
         else:
             print(f"Target device is not opened. Command: {command}")
 
-    def read(self, timeout=1):
-        if self.ser is not None and self.ser.is_open:
-            print("reading...")
-            try:
-                start_time = time.time()
-                while time.time() - start_time < timeout:
-                    if self.ser.in_waiting > 0:
-                        response = self.ser.read(self.ser.in_waiting)
-                        response = response.decode("utf-8").strip()
-                        if self.is_log_message:
-                            print(
-                                f"[bold blue]Recv from {self.device} :[/bold blue] {response}"
-                            )
-                        return response
-                    time.sleep(0.01)
-                print("reading timeout")
-                return None
-            except Exception as e:
-                print(f"Error when reading serial port: {str(e)}")
-                return None
-        elif self.only_simulate:
-            simulated_response = "simulate response"
-            if self.is_log_message:
-                print(
-                    f"[bold blue]Recv from simulate device:[/bold blue] {simulated_response}"
-                )
-            return simulated_response
+    def send_command(self, address="", command="", value=None):
+        if command == "":
+            print("Command can't be empty")
+            return
+        if value is not None:
+            command = self.addressed_cmd(address, command + str(value))
+        else:
+            command = self.addressed_cmd(address, command)
+
+        self.sendQueue.put_nowait(command)
+
+    def update(self):
+
+        while self.is_updating:
+            if self.ser is not None:
+                if self.ser.in_waiting > 0:
+                    response = self.ser.read(self.ser.in_waiting)
+                    response = response.decode("ascii", errors="ignore").strip()
+                    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()
+
+    def handle_recv(self, response):
+        if "*" in response:
+            print(f"[bold green](o)buffered_ack[/bold green]")
+        elif "%" in response:
+            print(f"[bold green](v)success_ack[/bold green]")
+        elif "?" in response:
+            print(f"[bold red](x)fail_ack[/bold red]")
         else:
-            print("Device not open, read fail.")
-            return None
+            print(f"[bold blue]Received from {self.device}: [/bold blue]", response)
+            self.recvQueue.put_nowait(response)
+
+            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 enable(self, motor_address="", enable=True):
-        cmd = "ME" if enable else "MD"
-        self.send(self.addressed_cmd(motor_address, cmd))
-
-    def move_absolute(self, motor_address="", position=0, speed=0.15):
-        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):
-        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"):
-        self.send(self.addressed_cmd(motor_address, "JS{}".format(speed)))
-        time.sleep(0.01)
-        self.send(self.addressed_cmd(motor_address, "CJ"))
-        # self.send(self.addressed_cmd(motor_address, "CS{}".format(speed)))
-
-    def change_jog_speed(self, motor_address="", speed=0.15):
-        self.send(self.addressed_cmd(motor_address, "CS{}".format(speed)))
-
-    def stop_jog(self, motor_address=""):
-        self.send(self.addressed_cmd(motor_address, "SJ"))
-
-    def stop(self, motor_address=""):
-        self.send(self.addressed_cmd(motor_address, "ST"))
-
-    def stop_with_deceleration(self, motor_address=""):
-        self.send(self.addressed_cmd(motor_address, "STD"))
-
-    def stop_and_kill(self, motor_address="", with_deceleration=True):
-        if with_deceleration:
-            self.send(self.addressed_cmd(motor_address, "SKD"))
-        else:
-            self.send(self.addressed_cmd(motor_address, "SK"))
-
-    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 calibrate(self, motor_address="", speed=0.3, onStart=None, onComplete=None):
-        self.send(self.addressed_cmd(motor_address, "VE{}".format(speed)))
-        # time.sleep(0.01)
-        # self.send(self.addressed_cmd(motor_address, "DI10"))
-        # time.sleep(0.01)
-        self.send(self.addressed_cmd(motor_address, "SH3F"))
-        # time.sleep(0.01)
-        self.send(self.addressed_cmd(motor_address, "EP0"))
-        # time.sleep(0.01)
-        self.send(self.addressed_cmd(motor_address, "SP0"))
-
-    def alarm_reset(self, motor_address=""):
-        self.send(self.addressed_cmd(motor_address, "AR"))
-
-    # speed slow= 0.25, medium=1, fast=5
-    def set_transmit_delay(self, motor_address="", delay=15):
-        self.send(self.addressed_cmd(motor_address, "TD{}".format(delay)))
+    # 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)
 
-    # endregion
-
-    # region motor status functions
-    def get_position(self, motor_address):
-        self.send(self.addressed_cmd(motor_address, "IP"))
-        return self.read()
-        # self.new_value_event.wait(timeout=0.5)
-        # return self.get_value()
-
-    def get_temperature(self, motor_address):
-        self.send(self.addressed_cmd(motor_address, "IT"))
-        # self.new_value_event.wait(timeout=0.5)
-        return self.read()
-        # return int(self.get_value()) / 10
-
-    def get_sensor_status(self, motor_address):
-        self.send(self.addressed_cmd(motor_address, "IS"))
-        return self.read()
-        # self.new_value_event.wait(timeout=0.5)
-        # return self.get_value()
-
-    def get_votalge(self, motor_address):
-        self.send(self.addressed_cmd(motor_address, "IU"))
-        return self.read()
-        # self.new_value_event.wait(timeout=0.5)
-        # return self.get_value()
-
-    def get_acceleration(self, motor_address):
-        self.send(self.addressed_cmd(motor_address, "AC"))
-        return self.read()
-        # self.new_value_event.wait(timeout=0.5)
-        # return self.get_value()
-
-    def get_deceleration(self, motor_address):
-        self.send(self.addressed_cmd(motor_address, "DE"))
-        return self.read()
-        # self.new_value_event.wait(timeout=0.5)
-        # return self.get_value()
-
-    def get_velocity(self, motor_address):
-        self.send(self.addressed_cmd(motor_address, "VE"))
-        return self.read()
-        # self.new_value_event.wait(timeout=0.5)
-        # return self.get_value()
-
-    def get_distance(self, motor_address):
-        self.send(self.addressed_cmd(motor_address, "DI"))
-        return self.read()
-        # self.new_value_event.wait(timeout=0.5)
-        # return self.get_value()
-
-    def get_jog_speed(self, motor_address):
-        self.send(self.addressed_cmd(motor_address, "JS"))
-        # self.new_value_event.wait(timeout=0.5)
-        # return self.get_value()
-        return self.read()
-
-    def get_info(self, motor_address, progress=None):
-        self.set_return_format_dexcimal(motor_address)
-        self.motor_wait(motor_address, 0.1)
-        totalInfoCount = 7
-        pos = self.extractValueFromResponse(self.get_position(motor_address))
-        if progress:
-            progress(round(1 / totalInfoCount, 1))
-        temp = (
-            int(self.extractValueFromResponse(self.get_temperature(motor_address))) / 10
+    def home(self, motor_address="", speed=0.3, onComplete=None):
+        self.send_command(
+            address=motor_address, command=StepperCommand.VELOCITY, value=speed
         )
-        if progress:
-            progress(round(2 / totalInfoCount, 1))
-        vol = int(self.extractValueFromResponse(self.get_votalge(motor_address))) / 10
-        if progress:
-            progress(round(3 / totalInfoCount, 1))
-        accel = self.extractValueFromResponse(self.get_acceleration(motor_address))
-        if progress:
-            progress(round(4 / totalInfoCount, 1))
-        decel = self.extractValueFromResponse(self.get_deceleration(motor_address))
-        if progress:
-            progress(round(5 / totalInfoCount, 1))
-        jogsp = self.extractValueFromResponse(self.get_jog_speed(motor_address))
-        if progress:
-            progress(round(6 / totalInfoCount, 1))
-        info = {
-            "pos": pos,
-            "temp": temp,
-            "vol": vol,
-            "accel": accel,
-            "decel": decel,
-            "jogsp": jogsp,
-        }
-        if progress:
-            progress(round(7 / totalInfoCount))
-
-        return info
-
-    def get_status(self, motor_address) -> str:
-        self.set_return_format_dexcimal(motor_address)
-        self.send(self.addressed_cmd(motor_address, "RS"))
-        self.new_value_event.wait(timeout=0.5)
-        return str(self.get_value())
-
-    def set_return_format_dexcimal(self, motor_address):
-        self.send(self.addressed_cmd(motor_address, "IFD"))
+        self.send_command(
+            address=motor_address, command=StepperCommand.HOME, value="3F"
+        )
+        self.send_command(
+            address=motor_address, command=StepperCommand.ENCODER_POSITION
+        )
+        self.send_command(
+            address=motor_address, command=StepperCommand.SET_POSITION, value=0
+        )
+        if onComplete:
+            self.get_status(
+                motor_address, StepperCommand.SET_POSITION, callback=onComplete
+            )
 
-    def set_return_format_hexdecimal(self, motor_address):
-        self.send(self.addressed_cmd(motor_address, "IFH"))
+    # endregion
+    def get_status(self, motor_address, command: StepperCommand, callback=None):
+        command = self.addressed_cmd(motor_address, command)
+        if callback:
+            self.pending_callbacks.put_nowait(callback)
+        self.sendQueue.put_nowait(command)
 
     # endregion
 
     # region utility functions
-    def motor_wait(self, motor_address, wait_time):
-        self.send(self.addressed_cmd(motor_address, "WT{}".format(wait_time)))
 
     def addressed_cmd(self, motor_address, command):
-        if motor_address == "":
-            return f"~{command}"
         return f"{motor_address}{command}"
 
-    def extractValueFromResponse(self, response):
-        pattern = r"=(.*)"
-        if response == None:
-            return None
-        result = re.search(pattern, response)
-        if result:
-            return result.group(1)
-        else:
-            return None
-
-    def get_value(self):
-        print("Waiting for value")
-        self.new_data_event.wait(timeout=0.5)
-        print("Recv:" + self.listeningBufferPre)
-        self.new_data_event.clear()
-        return self.listeningBufferPre
-        # if "%" in self.listeningBufferPre:
-        #     return "success_ack"
-        # if "?" in self.listeningBufferPre:
-        #     return "fail_ack"
-        # if "*" in self.listeningBufferPre:
-        #     return "buffered_ack"
-        # self.new_value_event.set()
-        # pattern = r"=(\w+(?:\.\w+)?|\d+(?:\.\d+)?)"
-        # result = re.search(pattern, self.listeningBufferPre)
-        # self.listeningBufferPre = ""
-        # self.new_value_event.clear()
-        # if result:
-        #     return result.group(1)
-        # else:
-        #     return "No_value_found"
-
 
 # endregion
 

{moons_motor-0.0.11.dist-info → moons_motor-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: moons_motor
-Version: 0.0.11
+Version: 0.1.3
 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
@@ -16,6 +16,7 @@ Requires-Dist: pyserial
 Requires-Dist: rich
 Requires-Dist: python-socketio
 Requires-Dist: requests
+Dynamic: license-file
 
 # Moons Motor
 

moons_motor-0.1.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+moons_motor/__init__.py,sha256=qOpsRwizV-DpKSvNzyvj8ju3cs6vwgIICur1Oe6sxOA,27
+moons_motor/motor.py,sha256=rpunJXViqvSpMW9uRJDctBPyfSJnZh5WZtBtci16-Ck,13308
+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.3.dist-info/licenses/LICENSE,sha256=nsYjO800SjIjI85y2kVHR5mC3tca2vs4kK_BhNe89bM,1074
+moons_motor-0.1.3.dist-info/METADATA,sha256=Zaj25TLKPvBv0qJWRInaALURr8bcOtDLNWfxQymFdtY,1304
+moons_motor-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+moons_motor-0.1.3.dist-info/top_level.txt,sha256=0dE-CR5_NYBw34jHIDGQNWpMllzO6mtUIuKyRv_rJLg,12
+moons_motor-0.1.3.dist-info/RECORD,,

{moons_motor-0.0.11.dist-info → moons_motor-0.1.3.dist-info}/WHEEL

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

moons_motor-0.0.11.dist-info/RECORD

@@ -1,11 +0,0 @@
-moons_motor/__init__.py,sha256=qOpsRwizV-DpKSvNzyvj8ju3cs6vwgIICur1Oe6sxOA,27
-moons_motor/motor.py,sha256=Fbp08XMgAjLiyGqFD-WXsGXBNrgCiclsopYxT0tq9Xk,16077
-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.0.11.dist-info/LICENSE,sha256=nsYjO800SjIjI85y2kVHR5mC3tca2vs4kK_BhNe89bM,1074
-moons_motor-0.0.11.dist-info/METADATA,sha256=Pde70Xqjwl4hZmQZMig8ik6_T1XqutMWs5wkkAkTVdg,1282
-moons_motor-0.0.11.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-moons_motor-0.0.11.dist-info/top_level.txt,sha256=0dE-CR5_NYBw34jHIDGQNWpMllzO6mtUIuKyRv_rJLg,12
-moons_motor-0.0.11.dist-info/RECORD,,