robocad-py 0.0.2.3__tar.gz → 1.0.2.3__tar.gz

robocad-py-1.0.2.3/LICENSE

@@ -0,0 +1,27 @@
+Freeware licence Terms
+
+Copyright (c) 2024 Airat Abdrakov
+
+THIS SOFTWARE IS COPYRIGHTED, AND THE OWNER OF THE COPYRIGHT CLAIMS ALL EXCLUSIVE RIGHTS TO SUCH SOFTWARE, EXCEPT AS licenced TO USERS HEREUNDER AND SUBJECT TO STRICT COMPLIANCE WITH THE TERMS OF THIS FREEWARE LICENSE.  
+
+Even though a licence fee is not paid for use of such Freeware, it does not mean that there are no conditions for using such Freeware. As a condition for granting you a licence to use Freeware programmes that are available through this repository, you agree to all of the following terms and conditions. You are deemed to have read, understood and accepted all such terms and conditions upon executing a download of any Freeware program.  
+
+If you fail to abide by any of the terms and conditions set forth herein, your licence to use such Freeware shall be immediately and automatically revoked, without any notice or other action by the Copyright Owner.
+
+TERMS AND CONDITIONS
+Background
+
+1.	You are granted a non-exclusive licence to use the Downloaded Software subject to your compliance with all of the terms and conditions of this Freeware License.
+2.	You may only use the software on a single computer that you own, lease or control. You may make one backup copy of the software for your own use to replace the primary copy in the event of hard-drive failure or other unavailability of the primary copy. The backup copy shall retain all copyright notices.
+3.	You are only granted a licence for the machine-readable (object code portion of the software) and the code provided in the repository. You will not modify, enhance, reverse engineer or otherwise alter the software from its current [Province].
+4.	You may not use the software for multiple users or on a local area network without written consent from the Licensor.
+5.	You may not distribute, copy, publish, assign, sell, bargain, convey, transfer, pledge, lease or grant any further rights to use the software.
+6.	You will not have any proprietary rights in and to the software. You acknowledge and agree that the Licensor retains all copyrights and other proprietary rights in and to the software.
+7.	Your licence to use the software shall be revocable by the Licensor upon written notice to you. This licence shall automatically terminate upon your violation of the terms hereof or upon your use of the software beyond the scope of the licence provided herein.
+8.	Use within the scope of this licence is free of charge and no royalty or licencing fees shall be payable by you. Use beyond the scope of this licence shall constitute copyright infringement.
+9.	This licence shall be effective and bind you upon your downloading of the software.
+10.	You accept the software on an “AS IS” and with all faults basis. No representations and warranties are made to you regarding any aspect of the software.
+11.	THE LICENSOR HEREBY DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, RELATIVE TO THE SOFTWARE, INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE OR MERCHANTABILITY. LICENSOR SHALL NOT BE LIABLE OR RESPONSIBLE FOR ANY DAMAGES, INJURIES OR LIABILITIES CAUSED DIRECTLY OR INDIRECTLY FROM THE USE OF THE SOFTWARE, INCLUDING BUT NOT LIMITED TO INCIDENTAL, CONSEQUENTIAL OR SPECIAL DAMAGES.
+12.	This Freeware licence shall be interpreted under the laws of Russian Federation. You agree that all controversies pertaining to the software and/or this Freeware Agreement shall be brought in the courts of Russian Federation. You hereby submit to the jurisdictions of such court. However, courts located in Russian Federation shall have jurisdiction over copyright claims brought by the Licensor, and you hereby submit to the jurisdiction of the court located in the Russian Federation.
+13.	Licensor’s failure to enforce any rights hereunder or its copyright in the software shall not be construed as amending this agreement or waiving any of Licensor’s rights hereunder or under any provision of 
+Russian Federation law.

robocad-py-1.0.2.3/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.1
+Name: robocad-py
+Version: 1.0.2.3
+Summary: python lib for real and virtual robots
+Home-page: https://github.com/Soft-V/robocad-py
+Author: Airat Abdrakov
+Author-email: softvery@yandex.ru
+License: MIT
+Keywords: simulator,robotics,robot,3d,raspberry,control
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Education
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+License-File: LICENSE
+
+Python library for real and virtual robots
+
+# Change Log
+
+## 0.0.0.1
+- First Release
+
+## 0.0.0.2
+- Real camera exception checker added
+
+## 0.0.0.5
+- Hope this works
+
+## 0.0.0.6
+- Servo motors should work now
+
+## 0.0.0.7
+- Thread joins added
+
+## 0.0.0.8
+- Thread joins fixed :)
+
+## 0.0.0.9
+- Thread joins fixed 2 :)
+
+## 0.0.1.1
+- Library fully changed according to the new requirements

robocad-py-1.0.2.3/robocad/common.py

@@ -0,0 +1,20 @@
+class Common:
+    # logger object
+    logger = None
+    # control the type of the shufflecad work
+    on_real_robot: bool = True
+
+    power: float = 0.0
+
+    # some things
+    spi_time_dev: float = 0
+    rx_spi_time_dev: float = 0
+    tx_spi_time_dev: float = 0
+    spi_count_dev: float = 0
+    com_time_dev: float = 0
+    rx_com_time_dev: float = 0
+    tx_com_time_dev: float = 0
+    com_count_dev: float = 0
+    temperature: float = 0
+    memory_load: float = 0
+    cpu_load: float = 0

robocad-py-1.0.2.3/robocad/internal/logger.py

@@ -0,0 +1,18 @@
+import logging
+from datetime import datetime
+from robocad.common import Common
+
+
+class Logger:
+    FORMAT = '[%(levelname)s]\t(%(threadName)-10s)\t%(message)s'
+
+    def __init__(self):
+        log_path = '/home/pi/robocad/logs/cad_main.log' if Common.on_real_robot else './cad_main.log'
+        logging.basicConfig(level=logging.INFO,
+                            format=self.FORMAT,
+                            filename=log_path,
+                            filemode='w+')
+        self.main_logger = logging.getLogger()
+
+    def write_main_log(self, s: str):
+        self.main_logger.info(datetime.now().strftime("%H:%M:%S") + " " + s)

{robocad-py-0.0.2.3/robocad/pycad → robocad-py-1.0.2.3/robocad/internal/studica}/COM.py

@@ -3,7 +3,7 @@ import sys
 import time
 from threading import Thread
 
-from robocad.shufflecad.shared import InfoHolder
+from robocad.common import Common
 from .shared import TitanStatic
 from .shared import LibHolder
 from funcad.funcad import Funcad
@@ -31,29 +31,29 @@ class TitanCOM:
             while not cls.stop_th:
                 tx_time: float = time.time() * 1000
                 tx_data = cls.set_up_tx_data()
-                InfoHolder.tx_com_time_dev = str(round(time.time() * 1000 - tx_time, 2))
+                Common.tx_com_time_dev = round(time.time() * 1000 - tx_time, 2)
 
                 rx_data: bytearray = LibHolder.rw_usb(tx_data)
 
                 rx_time: float = time.time() * 1000
                 cls.set_up_rx_data(rx_data)
-                InfoHolder.rx_com_time_dev = str(round(time.time() * 1000 - rx_time, 2))
+                Common.rx_com_time_dev = round(time.time() * 1000 - rx_time, 2)
 
                 comm_counter += 1
                 if time.time() - send_count_time > 1:
                     send_count_time = time.time()
-                    InfoHolder.com_count_dev = str(comm_counter)
+                    Common.com_count_dev = comm_counter
                     comm_counter = 0
 
                 time.sleep(0.001)
-                InfoHolder.com_time_dev = str(round(time.time() * 10000) - start_time)
+                Common.com_time_dev = round(time.time() * 10000) - start_time
                 start_time = round(time.time() * 10000)
         except Exception as e:
             LibHolder.stop_usb()
             exc_type, exc_obj, exc_tb = sys.exc_info()
             file_name = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
-            InfoHolder.logger.write_main_log(" ".join(map(str, [exc_type, file_name, exc_tb.tb_lineno])))
-            InfoHolder.logger.write_main_log(str(e))
+            Common.logger.write_main_log(" ".join(map(str, [exc_type, file_name, exc_tb.tb_lineno])))
+            Common.logger.write_main_log(str(e))
 
     @staticmethod
     def set_up_rx_data(data: bytearray) -> None:
@@ -76,7 +76,7 @@ class TitanCOM:
                     TitanStatic.limit_h_3 = Funcad.access_bit(data[10], 2)
 
         else:
-            InfoHolder.logger.write_main_log("received wrong data " + " ".join(map(str, data)))
+            Common.logger.write_main_log("received wrong data " + " ".join(map(str, data)))
 
     @staticmethod
     def set_up_tx_data() -> bytearray:

{robocad-py-0.0.2.3/robocad/pycad → robocad-py-1.0.2.3/robocad/internal/studica}/SPI.py

@@ -3,7 +3,7 @@ import sys
 import time
 from threading import Thread
 
-from robocad.shufflecad.shared import InfoHolder
+from robocad.common import Common
 from .shared import VMXStatic
 from .shared import LibHolder
 from funcad.funcad import Funcad
@@ -33,29 +33,29 @@ class VMXSPI:
             while not cls.stop_th:
                 tx_time: float = time.time() * 1000
                 tx_list = cls.set_up_tx_data()
-                InfoHolder.tx_spi_time_dev = str(round(time.time() * 1000 - tx_time, 2))
+                Common.tx_spi_time_dev = round(time.time() * 1000 - tx_time, 2)
 
                 rx_list: bytearray = LibHolder.rw_spi(tx_list)
 
                 rx_time: float = time.time() * 1000
                 cls.set_up_rx_data(rx_list)
-                InfoHolder.rx_spi_time_dev = str(round(time.time() * 1000 - rx_time, 2))
+                Common.rx_spi_time_dev = round(time.time() * 1000 - rx_time, 2)
 
                 comm_counter += 1
                 if time.time() - send_count_time > 1:
                     send_count_time = time.time()
-                    InfoHolder.spi_count_dev = str(comm_counter)
+                    Common.spi_count_dev = comm_counter
                     comm_counter = 0
 
                 time.sleep(0.002)
-                InfoHolder.spi_time_dev = str(round(time.time() * 1000 - start_time, 2))
+                Common.spi_time_dev = round(time.time() * 1000 - start_time, 2)
                 start_time = time.time() * 1000
         except (Exception, EOFError) as e:
             LibHolder.stop_spi()
             exc_type, exc_obj, exc_tb = sys.exc_info()
             file_name = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
-            InfoHolder.logger.write_main_log(" ".join(map(str, [exc_type, file_name, exc_tb.tb_lineno])))
-            InfoHolder.logger.write_main_log(str(e))
+            Common.logger.write_main_log(" ".join(map(str, [exc_type, file_name, exc_tb.tb_lineno])))
+            Common.logger.write_main_log(str(e))
 
     @classmethod
     def set_up_rx_data(cls, data: bytearray) -> None:
@@ -67,7 +67,7 @@ class VMXSPI:
             VMXStatic.ultrasound_2 = us2_ui / 100
 
             power: float = ((data[8] & 0xff) << 8 | (data[7] & 0xff)) / 100
-            InfoHolder.power = str(power)
+            Common.power = power
 
             # calc yaw unlim
             new_yaw = (yaw_ui / 100) * (1 if Funcad.access_bit(data[9], 1) else -1)

{robocad-py-0.0.2.3/robocad/robocadSim → robocad-py-1.0.2.3/robocad/internal/studica}/connection.py

@@ -2,18 +2,17 @@ import socket
 import threading
 import time
 import warnings
+import struct
 
-from robocad.shufflecad.shared import InfoHolder
+from robocad.common import Common
 
 
 class ListenPort:
-    def __init__(self, port: int, is_camera=False):
+    def __init__(self, port: int):
         self.__port = port
-        self.__is_camera = is_camera
 
         # other
         self.__stop_thread = False
-        self.out_string = ''
         self.out_bytes = b''
 
         self.__sct = None
@@ -26,38 +25,32 @@ class ListenPort:
     def listening(self):
         self.__sct = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP)
         self.__sct.connect(('127.0.0.1', self.__port))
-        InfoHolder.logger.write_main_log("connected: " + str(self.__port))
+        Common.logger.write_main_log("connected: " + str(self.__port))
         while not self.__stop_thread:
             try:
-                if self.__is_camera:
-                    self.__sct.sendall("Wait for size".encode('utf-16-le'))
-                    image_size = self.__sct.recv(4)
-                    if len(image_size) < 4:
-                        continue
-                    buffer_size = (image_size[3] & 0xff) << 24 | (image_size[2] & 0xff) << 16 | \
-                                  (image_size[1] & 0xff) << 8 | (image_size[0] & 0xff)
-                    self.__sct.sendall("Wait for image".encode('utf-16-le'))
-                    self.out_bytes = self.__sct.recv(buffer_size)
-                else:
-                    self.__sct.sendall("Wait for data".encode('utf-16-le'))
-                    data_size = self.__sct.recv(4)
-                    if len(data_size) < 4:
-                        continue
-                    length = (data_size[3] & 0xff) << 24 | (data_size[2] & 0xff) << 16 | \
-                             (data_size[1] & 0xff) << 8 | (data_size[0] & 0xff)
-                    self.out_bytes = self.__sct.recv(length)
-                    self.out_string = self.out_bytes.decode('utf-16-le')
+                dt = "Wait for data".encode('utf-16-le')
+                dt_ln = struct.pack('<I', len(dt))
+                self.__sct.sendall(dt_ln)
+                self.__sct.sendall(dt)
+
+                data_size = self.__sct.recv(4)
+                if len(data_size) < 4:
+                    continue
+                length = (data_size[3] & 0xff) << 24 | (data_size[2] & 0xff) << 16 | \
+                            (data_size[1] & 0xff) << 8 | (data_size[0] & 0xff)
+                self.out_bytes = self.__sct.recv(length)
                 # задержка для слабых компов
                 time.sleep(0.004)
-            except (ConnectionAbortedError, BrokenPipeError):
+            except (ConnectionAbortedError, BrokenPipeError, OSError):
                 # возникает при отключении сокета
                 break
-        InfoHolder.logger.write_main_log("disconnected: " + str(self.__port))
-        self.__sct.shutdown(socket.SHUT_RDWR)
-        self.__sct.close()
+        Common.logger.write_main_log("disconnected: " + str(self.__port))
+        try:
+            self.__sct.shutdown(socket.SHUT_RDWR)
+            self.__sct.close()
+        except (OSError, Exception): pass  # idc
 
     def reset_out(self):
-        self.out_string = ''
         self.out_bytes = b''
 
     def stop_listening(self):
@@ -67,19 +60,19 @@ class ListenPort:
             try:
                 self.__sct.shutdown(socket.SHUT_RDWR)
             except (OSError, Exception):
-                InfoHolder.logger.write_main_log("Something went wrong while shutting down socket on port " +
+                Common.logger.write_main_log("Something went wrong while shutting down socket on port " +
                                                  str(self.__port))
             if self.__thread is not None:
                 st_time = time.time()
                 # если поток все еще живой, ждем 1 секунды и закрываем сокет
                 while self.__thread.is_alive():
                     if time.time() - st_time > 1:
-                        InfoHolder.logger.write_main_log("Something went wrong. Rude disconnection on port " +
+                        Common.logger.write_main_log("Something went wrong. Rude disconnection on port " +
                                                          str(self.__port))
                         try:
                             self.__sct.close()
                         except (OSError, Exception):
-                            InfoHolder.logger.write_main_log("Something went wrong while closing socket on port " +
+                            Common.logger.write_main_log("Something went wrong while closing socket on port " +
                                                              str(self.__port))
                         st_time = time.time()
 
@@ -90,7 +83,7 @@ class TalkPort:
 
         # other
         self.__stop_thread = False
-        self.out_string = ''
+        self.out_bytes = b''
 
         self.__sct = None
         self.__thread = None
@@ -102,22 +95,27 @@ class TalkPort:
     def talking(self):
         self.__sct = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP)
         self.__sct.connect(('127.0.0.1', self.__port))
-        InfoHolder.logger.write_main_log("connected: " + str(self.__port))
+        Common.logger.write_main_log("connected: " + str(self.__port))
         while not self.__stop_thread:
             try:
-                self.__sct.sendall((self.out_string + "$").encode('utf-16-le'))
-                _ = self.__sct.recv(1024)  # ответ сервера
+                dt_ln = struct.pack('<I', len(self.out_bytes))
+                self.__sct.sendall(dt_ln)
+                self.__sct.sendall(self.out_bytes)
+                _ = self.__sct.recv(4)  # ответ сервера
+                _ = self.__sct.recv(4)  # ответ сервера
                 # задержка для слабых компов
                 time.sleep(0.004)
-            except (ConnectionAbortedError, BrokenPipeError):
+            except (ConnectionAbortedError, BrokenPipeError, OSError):
                 # возникает при отключении сокета
                 break
-        InfoHolder.logger.write_main_log("disconnected: " + str(self.__port))
-        self.__sct.shutdown(socket.SHUT_RDWR)
-        self.__sct.close()
+        Common.logger.write_main_log("disconnected: " + str(self.__port))
+        try:
+            self.__sct.shutdown(socket.SHUT_RDWR)
+            self.__sct.close()
+        except (OSError, Exception): pass  # idc
 
     def reset_out(self):
-        self.out_string = ''
+        self.out_bytes = b''
 
     def stop_talking(self):
         self.__stop_thread = True
@@ -126,42 +124,32 @@ class TalkPort:
             try:
                 self.__sct.shutdown(socket.SHUT_RDWR)
             except (OSError, Exception):
-                InfoHolder.logger.write_main_log("Something went wrong while shutting down socket on port " +
+                Common.logger.write_main_log("Something went wrong while shutting down socket on port " +
                                                  str(self.__port))
             if self.__thread is not None:
                 st_time = time.time()
                 # если поток все еще живой, ждем 1 секунды и закрываем сокет
                 while self.__thread.is_alive():
                     if time.time() - st_time > 1:
-                        InfoHolder.logger.write_main_log("Something went wrong. Rude disconnection on port " +
+                        Common.logger.write_main_log("Something went wrong. Rude disconnection on port " +
                                                          str(self.__port))
                         try:
                             self.__sct.close()
                         except (OSError, Exception):
-                            InfoHolder.logger.write_main_log("Something went wrong while closing socket on port " +
+                            Common.logger.write_main_log("Something went wrong while closing socket on port " +
                                                              str(self.__port))
                         st_time = time.time()
 
 
 class ParseChannels:
     @staticmethod
-    def parse_float_channel(txt: str):
-        try:
-            return tuple(map(float, txt.replace(',', '.').split(';')))
-        except (Exception, ValueError):
-            return tuple()
-
+    def join_studica_channel(lst: tuple) -> bytes:
+        if len(lst) < 14:
+            return b''
+        return struct.pack('14f', *lst)
+    
     @staticmethod
-    def parse_bool_channel(txt: str):
-        try:
-            return tuple(map(bool, map(int, txt.split(';'))))
-        except (Exception, ValueError):
+    def parse_studica_channel(data: bytes) -> tuple:
+        if len(data) < 52:
             return tuple()
-
-    @staticmethod
-    def join_float_channel(lst: tuple):
-        return ';'.join(map(str, lst))
-
-    @staticmethod
-    def join_bool_channel(lst: tuple):
-        return ';'.join(map(str, map(int, lst)))
+        return struct.unpack('<4i2f4Hf16B', data)

robocad-py-1.0.2.3/robocad/internal/studica/connection_base.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+import cv2
+
+
+class ConnectionBase(ABC):
+    @abstractmethod
+    def start(self) -> None:
+        pass
+
+    @abstractmethod
+    def stop(self) -> None:
+        pass
+
+    @abstractmethod
+    def get_camera(self) -> cv2.typing.MatLike:
+        pass

robocad-py-1.0.2.3/robocad/internal/studica/connection_real.py

@@ -0,0 +1,55 @@
+import subprocess
+from threading import Thread
+import time
+import cv2
+
+from robocad.common import Common
+from .connection_base import ConnectionBase
+
+from .SPI import VMXSPI
+from .COM import TitanCOM
+
+
+class ConnectionReal(ConnectionBase):
+    def start(self) -> None:
+        try:
+            self.__camera_instance = cv2.VideoCapture(0)
+        except Exception as e:
+            Common.logger.write_main_log("Exception while creating camera instance: ")
+            Common.logger.write_main_log(str(e))
+
+        VMXSPI.start_spi()
+        TitanCOM.start_com()
+        subprocess.run(['sudo', '/home/pi/pi-blaster/pi-blaster'])
+        self.__stop_robot_info_thread = False
+        self.__robot_info_thread: Thread = Thread(target=self.__update_rpi_cringe)
+        self.__robot_info_thread.daemon = True
+        self.__robot_info_thread.start()
+
+    def stop(self) -> None:
+        self.__stop_robot_info_thread = True
+        self.__robot_info_thread.join()
+        TitanCOM.stop_th = True
+        TitanCOM.th.join()
+        VMXSPI.stop_th = True
+        VMXSPI.th.join()
+
+    def get_camera(self) -> cv2.typing.MatLike:
+        try:
+            ret, frame = self.__camera_instance.read()
+            if ret:
+                return frame
+        except Exception:
+            # there could be an error if there is no camera instance
+            pass
+        return None
+    
+    def __update_rpi_cringe(self):
+        from gpiozero import CPUTemperature # type: ignore
+        import psutil # type: ignore
+        cpu_temp: CPUTemperature = CPUTemperature()
+        while not self.__stop_robot_info_thread:
+            Common.temperature = cpu_temp.temperature
+            Common.memory_load = psutil.virtual_memory().percent
+            Common.cpu_load = psutil.cpu_percent(interval=0.5)
+            time.sleep(0.5)

robocad-py-1.0.2.3/robocad/internal/studica/connection_sim.py

@@ -0,0 +1,106 @@
+from threading import Thread
+import time
+
+import cv2
+import numpy as np
+
+from .connection import TalkPort, ListenPort, ParseChannels
+from .shared import TitanStatic, VMXStatic
+from .connection_base import ConnectionBase
+
+
+class ConnectionSim(ConnectionBase):
+    __port_set_data: int = 65431
+    __port_get_data: int = 65432
+    __port_camera: int = 65438
+
+    __talk_channel: TalkPort = None
+    __listen_channel: ListenPort = None
+    __camera_channel: ListenPort = None
+    __update_thread: Thread = None
+    __stop_update_thread: bool = False
+
+    def start(self) -> None:
+        if (self.__talk_channel is None):
+            self.__talk_channel = TalkPort(self.__port_set_data)
+        self.__talk_channel.start_talking()
+        if (self.__listen_channel is None):
+            self.__listen_channel = ListenPort(self.__port_get_data)
+        self.__listen_channel.start_listening()
+        if (self.__camera_channel is None):
+            self.__camera_channel = ListenPort(self.__port_camera)
+        self.__camera_channel.start_listening()
+
+        self.__stop_update_thread = False
+        self.__update_thread = Thread(target=self.__update)
+        self.__update_thread.daemon = True
+        self.__update_thread.start()
+
+    def stop(self) -> None:
+        self.__stop_update_thread = True
+        self.__update_thread.join()
+        self.__talk_channel.stop_talking()
+        self.__listen_channel.stop_listening()
+        self.__camera_channel.stop_listening()
+
+    def get_camera(self) -> cv2.typing.MatLike:
+        camera_data = self.__camera_channel.out_bytes
+        if len(camera_data) == 921600:
+            nparr = np.frombuffer(camera_data, np.uint8)
+            if nparr.size > 0:
+                img_rgb = nparr.reshape(480, 640, 3)
+                img_bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
+                return img_bgr
+        return None
+
+    def __set_data(self, values: tuple) -> None:
+        self.__talk_channel.out_bytes = ParseChannels.join_studica_channel(values)
+
+    def __get_data(self) -> tuple:
+        return ParseChannels.parse_studica_channel(self.__listen_channel.out_bytes)
+    
+    def __update(self):
+        while not self.__stop_update_thread:
+            # set data
+            values = [TitanStatic.speed_motor_0,
+                      TitanStatic.speed_motor_1,
+                      TitanStatic.speed_motor_2,
+                      TitanStatic.speed_motor_3]
+            values.extend(VMXStatic.hcdio_values)
+            self.__set_data(tuple(values))
+
+            # get data
+            values = self.__get_data()
+            if len(values) > 0:
+                TitanStatic.enc_motor_0 = values[0]
+                TitanStatic.enc_motor_1 = values[1]
+                TitanStatic.enc_motor_2 = values[2]
+                TitanStatic.enc_motor_3 = values[3]
+                VMXStatic.ultrasound_1 = values[4]
+                VMXStatic.ultrasound_2 = values[5]
+                VMXStatic.analog_1 = values[6]
+                VMXStatic.analog_2 = values[7]
+                VMXStatic.analog_3 = values[8]
+                VMXStatic.analog_4 = values[9]
+                VMXStatic.yaw = values[10]
+
+                TitanStatic.limit_h_0 = values[11] == 1
+                TitanStatic.limit_l_0 = values[12] == 1
+                TitanStatic.limit_h_1 = values[13] == 1
+                TitanStatic.limit_l_1 = values[14] == 1
+                TitanStatic.limit_h_2 = values[15] == 1
+                TitanStatic.limit_l_2 = values[16] == 1
+                TitanStatic.limit_h_3 = values[17] == 1
+                TitanStatic.limit_l_3 = values[18] == 1
+
+                VMXStatic.flex_0 = values[19] == 1
+                VMXStatic.flex_1 = values[20] == 1
+                VMXStatic.flex_2 = values[21] == 1
+                VMXStatic.flex_3 = values[22] == 1
+                VMXStatic.flex_4 = values[23] == 1
+                VMXStatic.flex_5 = values[24] == 1
+                VMXStatic.flex_6 = values[25] == 1
+                VMXStatic.flex_7 = values[26] == 1
+            
+            # задержка для слабых компов
+            time.sleep(0.004)

{robocad-py-0.0.2.3/robocad/pycad → robocad-py-1.0.2.3/robocad/internal/studica}/shared.py

@@ -1,5 +1,6 @@
 import sys
 import ctypes
+from robocad.common import Common
 
 
 class LibHolder:
@@ -100,27 +101,35 @@ class VMXStatic:
     flex_6: bool = False
     flex_7: bool = False
 
+    hcdio_values: list = [0.0] * 10
+
     @classmethod
     def set_servo_angle(cls, angle: float, pin: int):
         dut: float = 0.000666 * angle + 0.05
+        cls.hcdio_values[pin] = dut
         VMXStatic.echo_to_file(str(cls.HCDIO_CONST_ARRAY[pin]) + "=" + str(dut))
 
     @classmethod
     def set_led_state(cls, state: bool, pin: int):
         dut: float = 0.2 if state else 0.0
+        cls.hcdio_values[pin] = dut
         VMXStatic.echo_to_file(str(cls.HCDIO_CONST_ARRAY[pin]) + "=" + str(dut))
 
     @classmethod
     def set_servo_pwm(cls, pwm: float, pin: int):
         dut: float = pwm
+        cls.hcdio_values[pin] = dut
         VMXStatic.echo_to_file(str(cls.HCDIO_CONST_ARRAY[pin]) + "=" + str(dut))
 
     @classmethod
     def disable_servo(cls, pin: int):
+        cls.hcdio_values[pin] = 0.0
         VMXStatic.echo_to_file(str(cls.HCDIO_CONST_ARRAY[pin]) + "=" + "0.0")
 
     @staticmethod
     def echo_to_file(st: str):
+        if not Common.on_real_robot:
+            return None
         original_stdout = sys.stdout
         with open('/dev/pi-blaster', 'w') as f:
             sys.stdout = f  # Change the standard output to the file we created.