Joint-python-library 0.0.3__py3-none-any.whl

acrome_joint/Slave_Device.py

@@ -0,0 +1,314 @@
+## this is master for connected devices.
+import struct
+from crccheck.crc import Crc32Mpeg2 as CRC32
+import time
+import enum
+from acrome_joint.serial_port import SerialPort
+'''
+COMMUNICATION PACKAGE => 
+HEADER, ID, DEVICE_FAMILY, PACKAGE_SIZE, COMMAND, STATUS, .............. DATA ................. , CRC
+'''
+
+PING_PACKAGE_SIZE = 10
+
+#Classical Device Indexes
+Index_Device_Classical = enum.IntEnum('Index', [
+	'Header',
+	'DeviceID',
+    'DeviceFamily',
+	'PackageSize',
+	'Command',
+    'Status',
+	'HardwareVersion',
+	'SoftwareVersion',
+    'Baudrate',
+], start=0)
+
+#Classical_Commands
+class Device_Commands(enum.IntEnum):
+    ACK = 0x80
+    SYNC = 0x40
+
+    PING = 0x00
+    WRITE = 0x01
+    READ = 0x02
+    EEPROM_SAVE = 0x03
+    ERROR_CLEAR = 0x04
+    REBOOT = 0x05
+    EEPROM_RESET = 0x06
+    BL_JUMP = 0x07
+    ENTER_CONFIGURATION = 0x08
+    ENTER_OPERATION = 0x09
+    ERROR = 0x10
+
+    ENTER_CONFIGURATION_ACK = 0x80 | 0x08       # ACK | ENTER_CONFIGURATION
+    ENTER_OPERATION_ACK = 0x80 | 0x09           # ACK | ENTER_OPERATION
+    WRITE_ACK = 0x80 | 0x01                     # ACK | WRITE
+    WRITE_SYNC = 0x40 | 0x01                    # SYNC | WRITE
+    EEPROM_SAVE_ACK = 0x80 | 0x03               # ACK | EEPROM_WRITE
+    EEPROM_SAVE_SYNC = 0x40 | 0x03              # SYNC | EEPROM_WRITE
+
+def set_variables_directly(header:int, device_family:int, id:int, status:int=0, *idx_val_pairs, ack = False, port:SerialPort):
+        # returns : did ACK come?
+        port._ph.flushInput()
+
+        fmt_str = '<BBBBBB'
+        var_count = 0
+        size = 0
+        for one_pair in idx_val_pairs:
+            try:
+                if len(one_pair) != 2:
+                    raise ValueError(f"{one_pair} more than a pair! It is not a pair")
+                else:
+                    fmt_str += ('B' + self._vars[one_pair[0]].type())
+                    var_count+=1
+                    size += (1 + self._vars[one_pair[0]].size())
+            except:
+                raise ValueError(f"{one_pair} is not proper pair")
+        
+        flattened_list = [item for sublist in idx_val_pairs for item in sublist]
+
+        struct_out = list(struct.pack(fmt_str, *[header, id, device_family, size + PING_PACKAGE_SIZE, Device_Commands.WRITE, status, *flattened_list]))
+        struct_out = bytes(struct_out) + struct.pack('<' + 'I', CRC32.calc(struct_out))
+        ack_size = PING_PACKAGE_SIZE
+
+
+        port._ph.write(struct_out)
+        raise NotImplementedError()
+
+        if _read_ack():
+            return True
+        else:
+            return False
+
+
+class Slave_Device():
+    SERIAL_HEADER = 0x55
+    _BROADCAST_ID = 0xFF
+
+    _BATCH_ID = 254
+    def __init__(self, id, device_family, variables, port:SerialPort):
+        self._port = port
+        self._header = self.SERIAL_HEADER
+        self._id = id
+        self._device_family = device_family
+        self._vars = variables
+        self._ack_size = 0
+        self.__post_sleep = 0.01
+        self.__device_init_sleep = 3
+        self.write_ack_enable = False
+
+    def enable_get_ack(self):
+        self.write_ack_enable = True
+
+    def _init_sleep(self):
+        time.sleep(self.__device_init_sleep)
+
+    def _post_sleep(self):
+        time.sleep(self.__post_sleep)
+    
+    def _write_port(self, data):
+        self._port._write_bus(data)
+
+    def _read_port(self, size) -> bytes:
+        return self._port._read_bus(size=size)
+    
+    def _parse_received(self, data):
+        id = data[Index_Device_Classical.DeviceID]
+        data = data[4:-4]
+        fmt_str = '<'
+
+        i = 0
+        while i < len(data):
+            fmt_str += 'B' + self._vars[data[i]].type()
+            i += self._vars[data[i]].size() + 1
+
+        unpacked = list(struct.unpack(fmt_str, data))
+        grouped = zip(*(iter(unpacked),) * 2)
+        for group in grouped:
+            self._vars[group[0]].value(group[1])
+    
+    def _read_ack(self) -> bool:
+        ret = self._read_port(self._ack_size)
+        if (ret == "True for test"):
+            return True
+        if(ret==None):
+            return False
+        if len(ret) == self._ack_size:
+            if (CRC32.calc(ret[:-4]) == struct.unpack('<I', ret[-4:])[0]):
+                if ret[Index_Device_Classical.PackageSize] > PING_PACKAGE_SIZE:
+                    self._parse_received(ret)
+                    return True
+                else:
+                    return True # ping islemi ve WRITE_ACK icin.
+            else:
+                return False
+        else:
+            return False
+        
+    def _read_var_no_timeout(self):
+        self._port._no_timeout()
+        ack_flag = self._read_ack()
+        self._port.set_timeout(0.01)
+        if ack_flag:
+            return True
+        else:
+            return False 
+        
+    def _pure_command_send(self, command:int):
+        fmt_str = '<BBBBBB'
+        struct_out = list(struct.pack(fmt_str, *[self._header, self._id, self._device_family, PING_PACKAGE_SIZE, command, 0]))
+        struct_out = bytes(struct_out) + struct.pack('<I', CRC32.calc(struct_out))
+        self._write_port(struct_out)
+        return struct_out
+
+    def ping(self):
+        self._pure_command_send(Device_Commands.PING)
+        self._ack_size = PING_PACKAGE_SIZE
+        if self._read_ack():
+            return True
+        else:
+            return False
+    
+    def get_variables(self, *indexes):
+        self._ack_size = 0
+        fmt_str = '<BBBBBB'+'B'*len(indexes)
+
+        struct_out = list(struct.pack(fmt_str, *[self._header, self._id, self._device_family ,len(indexes) + PING_PACKAGE_SIZE, Device_Commands.READ, 0, *indexes]))
+        struct_out = bytes(struct_out) + struct.pack('<' + 'I', CRC32.calc(struct_out))
+        for i in indexes:
+            self._ack_size += (self._vars[int(i)].size() + 1)
+        self._ack_size += PING_PACKAGE_SIZE
+
+        self._write_port(struct_out)
+
+        if self._read_ack():
+            return [self._vars[index].value() for index in indexes]
+        else:
+            return [None]
+
+    def set_variables(self, *idx_val_pairs, ack = False):
+        # returns : did ACK come?
+        fmt_str = '<BBBBBB'
+        var_count = 0
+        size = 0
+        for one_pair in idx_val_pairs:
+            try:
+                if len(one_pair) != 2:
+                    raise ValueError(f"{one_pair} more than a pair! It is not a pair")
+                else:
+                    fmt_str += ('B' + self._vars[one_pair[0]].type())
+                    var_count+=1
+                    size += (1 + self._vars[one_pair[0]].size())
+            except:
+                raise ValueError(f"{one_pair} is not proper pair")
+        
+        flattened_list = [item for sublist in idx_val_pairs for item in sublist]
+
+        struct_out = list(struct.pack(fmt_str, *[self._header, self._id, self._device_family, size + PING_PACKAGE_SIZE, Device_Commands.WRITE, 0, *flattened_list]))
+        struct_out = bytes(struct_out) + struct.pack('<' + 'I', CRC32.calc(struct_out))
+        self._ack_size = PING_PACKAGE_SIZE
+
+        self._write_port(struct_out)
+        if(self.write_ack_enable):
+            if self._read_ack():
+                return True
+            else:
+                return False
+        return False
+        
+    def reboot(self):
+        self._pure_command_send(Device_Commands.REBOOT)
+	
+    def eeprom_save(self):
+        self._pure_command_send(Device_Commands.EEPROM_SAVE)
+        
+    def factory_reset(self, ack=False):
+        self._pure_command_send(Device_Commands.EEPROM_RESET)
+
+    def enter_bootloader(self):
+        self._pure_command_send(Device_Commands.BL_JUMP)
+
+    def enter_operation(self):
+        self._pure_command_send(Device_Commands.ENTER_OPERATION)
+
+    def enter_configuration(self):
+        self._pure_command_send(Device_Commands.ENTER_CONFIGURATION)
+
+    def get_driver_info(self):
+        """ Get hardware and software versions from the driver
+
+        Args:
+            id (int): The device ID of the driver.
+
+        Returns:
+            dict | None: Dictionary containing versions or None.
+        """
+        st = dict()
+        data = self.get_variables([Index_Device_Classical.HardwareVersion, Index_Device_Classical.SoftwareVersion])
+        if data is not None:
+            ver = list(struct.pack('<I', data[0]))
+            st['HardwareVersion'] = "v{1}.{2}.{3}".format(*ver[::-1])
+            ver = list(struct.pack('<I', data[1]))
+            st['SoftwareVersion'] = "v{1}.{2}.{3}".format(*ver[::-1])
+
+            self.__driver_list[id]._config = st
+            return st
+        else:
+            return None
+        
+    def update_driver_id(self, id: int, id_new: int):
+        """ Update the device ID of the driver
+
+        Args:
+            id (int): The device ID of the driver
+            id_new (int): New device ID
+
+        Raises:
+            ValueError: Current or updating device IDs are not valid
+        """
+        if (id < 0) or (id > 254):
+            raise ValueError("{} is not a valid ID!".format(id))
+
+        if (id_new < 0) or (id_new > 254):
+            raise ValueError("{} is not a valid ID argument!".format(id_new))
+        
+        self.set_variables([Index_Device_Classical.DeviceID, id_new])
+        self._post_sleep()
+        
+        self.eeprom_save(id_new)
+        self._post_sleep()
+        self.reboot(id)
+        
+    def get_all_variable(self):
+        for i in range(0, len(self._vars), 10):
+            j = i
+            k = min(i + 9, len(self._vars) - 1)  # Son grupta sınırlamayı sağlar
+            index_list = list(range(j, k + 1))
+            self.read_var(*index_list) # her birisi maksimum data sayisiymis gibi dusunerek yazarsak 4 byte olur. her bir pakette 10 adet alsin. maksimuma vurmak istemedigimizden dolayi.
+
+class Data_():
+    def __init__(self, index, var_type, rw=True, value = 0):
+        self.__index = index
+        self.__type = var_type
+        self.__size  = struct.calcsize(self.__type)
+        self.__value = value
+        self.__rw = rw
+
+    def value(self, value=None):
+        if value is None:
+            return self.__value
+        elif self.__rw:
+            self.__value = struct.unpack('<' + self.__type, struct.pack('<' + self.__type, value))[0]
+
+    def index(self) ->enum.IntEnum:
+        return self.__index
+    
+    def writeable(self) -> bool:
+        return self.__rw
+
+    def size(self) -> int:
+        return self.__size
+	
+    def type(self) -> str:
+        return self.__type

acrome_joint/__init__.py

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

acrome_joint/joint.py

@@ -0,0 +1,323 @@
+import struct
+from crccheck.crc import Crc32Mpeg2 as CRC32
+import serial
+import time
+from packaging.version import parse as parse_version
+import requests
+import hashlib
+import tempfile
+from stm32loader.main import main as stm32loader_main
+import enum
+from acrome_joint.Slave_Device import *
+
+
+# enter here for extra commands: 
+#class Device_ExtraCommands(enum.IntEnum):
+	# .......... start with 11
+	# .......... end of extra commmands max: 39
+
+
+Index_Joint = enum.IntEnum('Index', [
+	'Header',
+	'DeviceID',
+	'DeviceFamily',
+	'PackageSize',
+	'Command',
+	'Status',
+	'HardwareVersion',
+	'SoftwareVersion',
+	'Baudrate', #'WritableStart' = iBaudrate
+	# user parameter start
+	'OperationMode',
+	'Enable',
+	'Vbus_read',
+	'Temprature_read',
+	'currentId_loop_kp',
+	'currentId_loop_ki',
+	'currentId_loop_kd',
+	'currentIq_loop_kp',
+	'currentIq_loop_ki',
+	'currentIq_loop_kd',
+	'velocity_loop_kp',
+	'velocity_loop_ki',
+	'velocity_loop_kd',
+	'position_loop_kp',
+	'position_loop_ki',
+	'position_loop_kd',
+	'max_position',
+	'min_position',
+	'max_velocity',
+	'max_current',
+	'current_Va',
+	'current_Vb',
+	'current_Vc',
+	'current_Ia',
+	'current_Ib',
+	'current_Ic',
+	'current_Id',
+	'current_Iq',
+	'current_velocity',
+	'current_position',
+	'current_electrical_degree',
+	'current_electrical_radian',
+	'setpoint_current',
+	'setpoint_velocity',
+	'setpoint_position',
+	'openloop_voltage_size',
+	'openloop_angle_degree',
+	'current_lock_angle_degree',
+	# user parameter end
+	'Config_TimeStamp',
+	'Config_Description',
+	'CRCValue',
+], start=0)
+
+
+
+def scan_blue_devices(port:SerialPort):
+	device = Blue(0, port)
+	available_devices = []
+
+	for id in range(0,255):
+		device._id = id
+		if(device.ping()):
+			available_devices.append(id)
+
+	return available_devices
+
+
+class Joint(Slave_Device):
+	_PRODUCT_TYPE = 0xDA
+	_PACKAGE_ESSENTIAL_SIZE = 6
+	_STATUS_KEY_LIST = ['EEPROM', 'Software Version', 'Hardware Version']
+	__RELEASE_URL = "https://api.github.com/repos/AAcrome-Smart-Motion-Devices/SMD-Blue-Firmware/releases/{version}"
+
+	class Operation_Mode():
+		OPERATION_OPENLOOP = 0
+		OPERATION_CURRENT_LOCK = 1
+		OPERATION_FOC_TORQUE = 2
+		OPERATION_FOC_VELOCITY = 3
+		OPERATION_FOC_POSITION = 4
+
+	def __init__(self, ID, port:SerialPort) -> bool:
+		self.__ack_size = 0
+		if ID > 254 or ID < 0:
+			raise ValueError("Device ID can not be higher than 254 or lower than 0!")
+		device_special_data = [
+            Data_(Index_Joint.Header, 'B', False, 0x55),
+            Data_(Index_Joint.DeviceID, 'B'),
+			Data_(Index_Joint.DeviceFamily, 'B'),
+            Data_(Index_Joint.PackageSize, 'B'),
+            Data_(Index_Joint.Command, 'B'),
+			Data_(Index_Joint.Status, 'B'),
+            Data_(Index_Joint.HardwareVersion, 'I'),
+            Data_(Index_Joint.SoftwareVersion, 'I'),
+            Data_(Index_Joint.Baudrate, 'I'),
+			# user parameter starts
+			Data_(Index_Joint.OperationMode, 'B'),
+			Data_(Index_Joint.Enable, 'B'),
+			Data_(Index_Joint.Vbus_read, 'f'),
+			Data_(Index_Joint.Temprature_read, 'f'),
+			Data_(Index_Joint.currentId_loop_kp, 'f'),
+			Data_(Index_Joint.currentId_loop_ki, 'f'),
+			Data_(Index_Joint.currentId_loop_kd, 'f'),
+			Data_(Index_Joint.currentIq_loop_kp, 'f'),
+			Data_(Index_Joint.currentIq_loop_ki, 'f'),
+			Data_(Index_Joint.currentIq_loop_kd, 'f'),
+			Data_(Index_Joint.velocity_loop_kp, 'f'),
+			Data_(Index_Joint.velocity_loop_ki, 'f'),
+			Data_(Index_Joint.velocity_loop_kd, 'f'),
+			Data_(Index_Joint.position_loop_kp, 'f'),
+			Data_(Index_Joint.position_loop_ki, 'f'),
+			Data_(Index_Joint.position_loop_kd, 'f'),
+			Data_(Index_Joint.max_position, 'i'),
+			Data_(Index_Joint.min_position, 'i'),
+			Data_(Index_Joint.max_velocity, 'f'),
+			Data_(Index_Joint.max_current, 'f'),
+			Data_(Index_Joint.current_Va, 'f'),
+			Data_(Index_Joint.current_Vb, 'f'),
+			Data_(Index_Joint.current_Vc, 'f'),
+			Data_(Index_Joint.current_Ia, 'f'),
+			Data_(Index_Joint.current_Ib, 'f'),
+			Data_(Index_Joint.current_Ic, 'f'),
+			Data_(Index_Joint.current_Id, 'f'),
+			Data_(Index_Joint.current_Iq, 'f'),
+			Data_(Index_Joint.current_velocity, 'f'),
+			Data_(Index_Joint.current_position, 'i'),
+			Data_(Index_Joint.current_electrical_degree, 'f'),
+			Data_(Index_Joint.current_electrical_radian, 'f'),
+			Data_(Index_Joint.setpoint_current, 'f'),
+			Data_(Index_Joint.setpoint_velocity, 'f'),
+			Data_(Index_Joint.setpoint_position, 'f'),
+			Data_(Index_Joint.openloop_voltage_size, 'f'),
+			Data_(Index_Joint.openloop_angle_degree, 'f'),
+			Data_(Index_Joint.current_lock_angle_degree, 'f'),
+			# user parameter end
+			Data_(Index_Joint.Config_TimeStamp, 'Q'),
+			Data_(Index_Joint.Config_Description, '100s'),
+            Data_(Index_Joint.CRCValue, 'I'),
+        ]
+		super().__init__(ID, self._PRODUCT_TYPE, device_special_data, port)
+		self._vars[Index_Joint.DeviceID].value(ID)
+
+	# user start for extra commands.
+	#def command(self): 
+
+	def __del__(self):
+		pass
+
+	def get_latest_fw_version(self):
+		""" Get the latest firmware version from the Github servers.
+
+		Returns:
+			String: Latest firmware version
+		"""
+		response = requests.get(url=self.__class__.__RELEASE_URL.format(version='latest'))
+		if (response.status_code in [200, 302]):
+			return (response.json()['tag_name'])
+
+	def update_fw_version(self, version=''):
+		""" Update firmware version with respect to given version string.
+
+		Args:
+			id (int): The device ID of the driver
+			version (str, optional): Desired firmware version. Defaults to ''.
+
+		Returns:
+			Bool: True if the firmware is updated
+		"""
+
+		fw_file = tempfile.NamedTemporaryFile("wb+",delete=False)
+		if version == '':
+			version = 'latest'
+		else:
+			version = 'tags/' + version
+
+		response = requests.get(url=self.__class__.__RELEASE_URL.format(version=version))
+		if response.status_code in [200, 302]:
+			assets = response.json()['assets']
+
+			fw_dl_url = None
+			md5_dl_url = None
+			for asset in assets:
+				if '.bin' in asset['name']:
+					fw_dl_url = asset['browser_download_url']
+				elif '.md5' in asset['name']:
+					md5_dl_url = asset['browser_download_url']
+
+			if None in [fw_dl_url, md5_dl_url]:
+				raise Exception("Could not found requested firmware file! Check your connection to GitHub.")
+
+			#  Get binary firmware file
+			md5_fw = None
+			response = requests.get(fw_dl_url, stream=True)
+			if (response.status_code in [200, 302]):
+				fw_file.write(response.content)
+				md5_fw = hashlib.md5(response.content).hexdigest()
+			else:
+				raise Exception("Could not fetch requested binary file! Check your connection to GitHub.")
+
+			#  Get MD5 file
+			response = requests.get(md5_dl_url, stream=True)
+			if (response.status_code in [200, 302]):
+				md5_retreived = response.text.split(' ')[0]
+				if (md5_fw == md5_retreived):
+
+					# Put the driver in to bootloader mode
+					self.enter_bootloader()
+					time.sleep(0.1)
+
+					# Close serial port
+					serial_settings = self._port._ph.get_settings()
+					self._port._ph.close()
+
+					# Upload binary
+					args = ['-p', self._port._ph.portstr, '-b', str(115200), '-e', '-w', '-v', fw_file.name]
+					stm32loader_main(*args)
+
+					# Delete uploaded binary
+					if (not fw_file.closed):
+						fw_file.close()
+
+					# Re open port to the user with saved settings
+					self._port._ph.apply_settings(serial_settings)
+					self._port._ph.open()
+					return True
+
+				else:
+					raise Exception("MD5 Mismatch!")
+			else:
+				raise Exception("Could not fetch requested MD5 file! Check your connection to GitHub.")
+		else:
+			raise Exception("Could not found requested firmware files list! Check your connection to GitHub.")
+		
+	def enable_torque(self, en: bool):
+		""" Enable power to the motor of the driver.
+
+    	Args:
+    	    id (int): The device ID of the driver
+    	    en (bool): Enable. True enables the torque.
+    	"""
+
+		self.set_variables([Index_Joint.Enable, en])
+		self._post_sleep()
+
+	def set_config_timeStamp(self):
+		epoch_seconds = int(time.time())
+		self.set_variables([Index_Joint.Config_TimeStamp, epoch_seconds])
+		self._post_sleep()
+		
+	def set_config_description(self, description:str):
+		if len(description) >= 100:
+			text = description[:99] + '\0'
+		else:
+			text = description + '\0'
+			text = text.ljust(100, ' ')
+		text = text.encode('ascii')  # veya utf-8 eğer uyumluysa
+
+		self.set_variables([Index_Joint.Config_Description, text])
+		self._post_sleep()
+
+
+
+	def get_FOC_parameters(self, package_number:int):
+		if package_number >= 4:
+			raise "invalid package number ex: 0, 1, 2"
+		classic_package = [
+			Index_Joint.Enable,
+			Index_Joint.current_Id, Index_Joint.current_Iq,
+			Index_Joint.current_velocity, Index_Joint.current_position,
+			Index_Joint.Temprature_read,
+			Index_Joint.setpoint_current, Index_Joint.setpoint_velocity, Index_Joint.setpoint_position
+		]
+		package_0 = [
+			Index_Joint.currentId_loop_kp, 
+			Index_Joint.currentId_loop_ki, 
+			Index_Joint.currentId_loop_kd, 
+			Index_Joint.currentIq_loop_kp, 
+			Index_Joint.currentIq_loop_ki, 
+			Index_Joint.currentIq_loop_kd, 
+		]
+		package_1 = [
+			Index_Joint.velocity_loop_kp,
+			Index_Joint.velocity_loop_ki,
+			Index_Joint.velocity_loop_kd,
+		]
+		package_2 = [
+			Index_Joint.position_loop_kp,
+			Index_Joint.position_loop_ki,
+			Index_Joint.position_loop_kd,
+		]
+
+		if package_number == 0:
+			return self.get_variables(*classic_package , *package_0)
+			
+		elif package_number == 1:
+			return self.get_variables(*classic_package , *package_1)
+			
+		elif package_number == 2:
+			return self.get_variables(*classic_package , *package_2)
+		
+		elif package_number == 3:
+			return self.get_variables(*classic_package)
+		

acrome_joint/serial_port.py

@@ -0,0 +1,59 @@
+import serial
+
+class SerialPort:
+    def __init__(self, port_name, baudrate=921600, timeout=0.1, isTest:bool=False):
+        self.port_name = port_name
+        self.baudrate = baudrate
+        self.timeout = timeout
+        self.isTest = isTest
+        if(self.isTest != True):
+            self._ph = serial.Serial(port=self.port_name, baudrate=self.baudrate, timeout=self.timeout)
+
+    def close_port(self):
+        if self.isTest:
+            print(f"virtual port destroyed.")
+        else:
+            if self._ph and self._ph.is_open:
+                self._ph.reset_input_buffer()
+                self._ph.reset_output_buffer()
+                self._ph.close()
+                print(f"Port '{self.port_name}' shut down.")
+            else:
+                print(f"Port '{self.port_name}' already closed.")
+
+    def __del__(self):
+        try:
+            self.close_port()
+        except Exception as e:
+            print(f"Port yok edilirken bir hata oluştu: {e}")
+        
+    def _write_bus(self,data):
+        if(self.isTest == True):
+            print(list(data))
+        else:
+            self._ph.flushInput()
+            self._ph.write(data)
+        pass
+
+    def _read_bus(self, size):
+        if(self.isTest == False):
+            return self._ph.read(size=size)
+        else:
+            print("Read Bus(TEST!)")
+            return "True for test"
+
+    def _no_timeout(self):
+        notimeout = 50 #in seconds
+        if(self.isTest):
+            print(f"port timeout update is setted to {notimeout} (TEST!)")
+        else:
+            self._ph.timeout = notimeout
+
+    def set_timeout(self, timeout):
+        if(self.isTest):
+            print(f"port timeout update to {timeout} (TEST!)")
+        else:
+            self._ph.timeout = timeout
+
+
+