Joint-python-library 0.0.6__tar.gz → 0.0.7__tar.gz

{joint_python_library-0.0.6 → joint_python_library-0.0.7}/Joint_python_library.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Joint-python-library
-Version: 0.0.6
+Version: 0.0.7
 Summary: Python library for interfacing with Acrome Robotic Arm Joint BLDC Motor Controllers. This Python library provides an easy-to-use interface for communication and control of BLDC motor controllers used in Acrome robotic arm joints. It is designed to simplify the integration of Acrome’s robotic joint actuators into custom applications, allowing developers and researchers to focus on building advanced robotic systems without dealing with low-level communication details.
 Home-page: https://github.com/Acrome-Smart-Motion-Devices/python-library-new
 Author: BeratComputer

{joint_python_library-0.0.6 → joint_python_library-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Joint-python-library
-Version: 0.0.6
+Version: 0.0.7
 Summary: Python library for interfacing with Acrome Robotic Arm Joint BLDC Motor Controllers. This Python library provides an easy-to-use interface for communication and control of BLDC motor controllers used in Acrome robotic arm joints. It is designed to simplify the integration of Acrome’s robotic joint actuators into custom applications, allowing developers and researchers to focus on building advanced robotic systems without dealing with low-level communication details.
 Home-page: https://github.com/Acrome-Smart-Motion-Devices/python-library-new
 Author: BeratComputer

{joint_python_library-0.0.6 → joint_python_library-0.0.7}/acrome_joint/Slave_Device.py

@@ -10,6 +10,7 @@ HEADER, ID, DEVICE_FAMILY, PACKAGE_SIZE, COMMAND, STATUS, .............. DATA ..
 '''
 
 PING_PACKAGE_SIZE = 10
+BROADCAST_ID = 255
 
 #Classical Device Indexes
 Index_Device_Classical = enum.IntEnum('Index', [
@@ -86,7 +87,9 @@ class Slave_Device():
     SERIAL_HEADER = 0x55
     _BROADCAST_ID = 0xFF
 
-    _BATCH_ID = 254
+    # NEW: device_family → variables (Data_ list) kaydı
+    _vars_registry = {}  # { device_family:int : [Data_, Data_, ...] }
+
     def __init__(self, id, device_family, variables, port:SerialPort):
         self._port = port
         self._header = self.SERIAL_HEADER
@@ -97,6 +100,7 @@ class Slave_Device():
         self.__post_sleep = 0.01
         self.__device_init_sleep = 3
         self.write_ack_enable = False
+        Slave_Device._vars_registry.setdefault(device_family, variables)
 
     def enable_get_ack(self):
         self.write_ack_enable = True
@@ -312,3 +316,107 @@ class Data_():
 	
     def type(self) -> str:
         return self.__type
+
+
+
+def write_sync_to_many(
+    port: SerialPort,
+    device_family: int,
+    index: int,
+    *id_value_pairs,
+    expect_ack: bool = False
+) -> bool:
+    """
+    Aynı değişken index'ini birden fazla cihaza WRITE_SYNC ile yazar.
+    Değer tipi, device_family'nin kayıtlı değişken tablosundan otomatik çekilir.
+
+    Args:
+        port (SerialPort): paylaşılan seri port
+        device_family (int): ürün ailesi (ör. Joint için 0xDA)
+        index (int | enum.IntEnum): yazılacak değişken indeksi
+        *id_value_pairs: [id, value] çiftleri (list/tuple), örn: [0, 123], [1, -45], ...
+        expect_ack (bool): ACK beklenip beklenmeyeceği
+
+    Returns:
+        bool: True = yazdı (veya ACK doğrulandı); False = ACK bekleniyorsa doğrulanamadı
+    """
+    import struct
+    from crccheck.crc import Crc32Mpeg2 as CRC32
+
+    # Sabitler
+    HEADER = Slave_Device.SERIAL_HEADER
+    BATCH_ID = Slave_Device._BROADCAST_ID
+    PING_PACKAGE_SIZE = 10
+    WRITE_SYNC = int(Device_Commands.WRITE_SYNC)
+    STATUS = 0
+
+    # Registry ve tip çözümü
+    reg = Slave_Device._vars_registry.get(device_family)
+    if reg is None:
+        raise RuntimeError(
+            f"Device family 0x{device_family:02X} için değişken tablosu bulunamadı. "
+            "Bu family’den en az bir cihaz instance'ı oluşturulmuş olmalı."
+        )
+
+    idx_int = int(index)
+    try:
+        var_type = reg[idx_int].type()  # 'f', 'i', 'B', ...
+    except Exception as e:
+        raise ValueError(f"Geçersiz index: {index} (family=0x{device_family:02X}).") from e
+
+    # id_value_pairs doğrula ve düzle
+    flat = []
+    for pair in id_value_pairs:
+        if (not isinstance(pair, (list, tuple))) or len(pair) != 2:
+            raise ValueError(f"{pair} geçersiz. [ID, value] olmalı.")
+        dev_id, val = pair
+        if not (0 <= int(dev_id) <= 254):
+            raise ValueError(f"ID {dev_id} geçersiz (0..254).")
+        # 'val' tipi Data_.type() ile belirlenecek; pack sırasında kontrol olur
+        flat.extend([int(dev_id), val])
+
+    count = len(flat) // 2
+    if count == 0:
+        raise ValueError("En az bir [ID, value] çifti gerekli.")
+
+    val_size = struct.calcsize('<' + var_type)
+
+    # Paket boyutu
+    # payload = index(1B) + her cihaz için (ID:1B + value:val_size)
+    payload_size = 1 + count * (1 + val_size)
+    package_size = PING_PACKAGE_SIZE + payload_size
+
+    # Format: header, BATCH_ID, family, size, cmd, status, index, (id, value)*N, crc
+    fmt = '<BBBBBB' + 'B' + ('B' + var_type) * count
+    data_no_crc = struct.pack(
+        fmt,
+        HEADER,
+        BATCH_ID,
+        device_family,
+        package_size,
+        WRITE_SYNC,
+        STATUS,
+        idx_int,
+        *flat
+    )
+    pkt = data_no_crc + struct.pack('<I', CRC32.calc(data_no_crc))
+
+    # Gönder
+    port._write_bus(pkt)
+
+    if not expect_ack:
+        return True
+
+    # Basit ACK okuma (PING_PACKAGE_SIZE kadar)
+    ack = port._read_bus(size=PING_PACKAGE_SIZE)
+    if not ack or len(ack) != PING_PACKAGE_SIZE:
+        return False
+
+    # CRC kontrolü
+    try:
+        data_part = ack[:-4]
+        crc_part = ack[-4:]
+        ok = (CRC32.calc(data_part) == struct.unpack('<I', crc_part)[0])
+        return bool(ok)
+    except Exception:
+        return False

{joint_python_library-0.0.6 → joint_python_library-0.0.7}/acrome_joint/joint.py

@@ -323,4 +323,113 @@ class Joint(Slave_Device):
 		
 		elif package_number == 3:
 			return self.get_variables(*classic_package)
-		
+		
+
+
+def set_joint_variables_sync(port:SerialPort, parameter_idx, *idx_val_pairs):
+    """
+    Build & send a WRITE_SYNC packet:
+      [HEADER, 0xFF, DEVICE_FAMILY, LENGTH, WRITE_SYNC, 0, PARAM_IDX, (ID, VALUE)*, CRC32]
+    - parameter_idx: single parameter index to write on each target
+    - idx_val_pairs: variadic list of 2-tuples/lists like (id, value) or [id, value]
+    - port: SerialPort-like object that has write(bytes) method
+
+    Returns: number of bytes written.
+    Raises: ValueError on malformed inputs.
+    """
+
+    # --- Validate & fetch parameter meta
+    if parameter_idx not in VARS:
+        raise ValueError(f"Unknown parameter index: {parameter_idx}")
+
+    var_desc = VARS[parameter_idx]
+    val_fmt = var_desc.type()     # e.g., 'f', 'i', 'H', etc. (little-endian will be applied later)
+    val_size = var_desc.size()    # size in bytes
+
+    # --- Validate pairs; normalize to tuples
+    pairs = []
+    for p in idx_val_pairs:
+        if not hasattr(p, '__len__') or len(p) != 2:
+            raise ValueError(f"{p} must be a pair like [ID, value]")
+        dev_id, value = p[0], p[1]
+
+        # Device ID range (0..254), 255 is reserved for broadcast in header
+        if not (0 <= int(dev_id) <= 254):
+            raise ValueError(f"Device ID out of range (0..254): {dev_id}")
+
+        pairs.append((int(dev_id), value))
+
+    if not pairs:
+        raise ValueError("At least one [ID, value] pair is required.")
+
+    # --- Compute size field used by your protocol
+    # Payload after the 6 fixed header bytes:
+    #   PARAM_IDX (1 byte)
+    # + for each pair: ID (1 byte) + VALUE (val_size bytes)
+    payload_size = 1 + len(pairs) * (1 + val_size)
+
+    # Protocol total-length field used in your other function:
+    # size + PING_PACKAGE_SIZE (to mirror your existing framing)
+    length_field = payload_size + PING_PACKAGE_SIZE
+
+    # --- Build struct format string & flat args
+    # Fixed header: '<BBBBBB'
+    # Then: PARAM_IDX (B)
+    # Then for each pair: ID (B) + VALUE (val_fmt)
+    fmt = '<BBBBBB' + 'B' + ''.join(['B' + val_fmt for _ in pairs])
+
+    flat = [
+        dev.SERIAL_HEADER,			# header
+        0xFF,                   # broadcast ID
+        DEVICE_FAMILY,          # device family
+        length_field,           # total length field
+        Device_Commands.WRITE_SYNC,  # command
+        0x00,                   # reserved
+        int(parameter_idx),     # parameter index
+    ]
+
+    # Append all (ID, VALUE) flattened; VALUE goes in native python type, struct packs it
+    for dev_id, value in pairs:
+        flat.append(dev_id)
+        flat.append(value)
+
+    # --- Pack without CRC
+    pkt_wo_crc = struct.pack(fmt, *flat)
+
+    # --- Append CRC32 (little-endian uint32 of the bytes above)
+    pkt = pkt_wo_crc + struct.pack('<I', CRC32.calc(pkt_wo_crc))
+
+    # --- Send over the provided port (broadcast sync write typically has no ACK)
+    written = port.write(pkt)
+    return written
+
+
+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

{joint_python_library-0.0.6 → joint_python_library-0.0.7}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="Joint-python-library",
-    version="0.0.6",
+    version="0.0.7",
     author="BeratComputer",
     author_email="beratdogan@acrome.net",
     description="Python library for interfacing with Acrome Robotic Arm Joint BLDC Motor Controllers. This Python library provides an easy-to-use interface for communication and control of BLDC motor controllers used in Acrome robotic arm joints. It is designed to simplify the integration of Acrome’s robotic joint actuators into custom applications, allowing developers and researchers to focus on building advanced robotic systems without dealing with low-level communication details.",