odrive 0.6.9.dev0__py37-none-win_amd64.whl

odrive/crypto.py

@@ -0,0 +1,369 @@
+"""
+Provides cryptographic methods for client/server authentication and device
+provisioning and authentication.
+
+The following algorithms and encodings are used:
+
+Signature algorithm: NIST P-256 (aka SECP256R1)
+Hashing algorithm: SHA-256
+
+Private key: 32 bytes private value (big endian)
+Public key: 32 bytes X coordinate (big endian) + 32 bytes Y coordinate (big endian)
+Signature: 32 bytes R (big endian) + 32 bytes S (big endian)
+
+These match the algorithms/encodings in ODrive hardware and must therefore not
+be changed.
+
+The following copyright applies to all core cryptographic code in this file:
+################################################################################
+# Copyright (c) 2022 Anirudha Bose                                             #
+# Adapted from https://onyb.gitbook.io/secp256k1-python under the MIT license. #
+################################################################################
+"""
+
+import base64
+import hashlib
+from random import randint
+from typing import Optional, NamedTuple
+
+class InvalidSignature(Exception):
+    pass
+
+def _gcd_extended(a, b):
+    """Extended Euclidean algorithm"""
+    if a == 0:
+        return b, 0, 1
+    gcd, x, y = _gcd_extended(b % a, a)
+    return (gcd, y - (b//a) * x, x)
+
+def _mod_pow(a, b, z):
+    # This function is only needed for Python <3.8. For 3.8+ the built-in
+    # function does all we need.
+    if b > 0:
+        return pow(a, b, z)
+    elif b == -1:
+        return _gcd_extended(a, z)[1]
+    else:
+        raise Exception("not implemented")
+
+class PrimeGaloisField(NamedTuple):
+    prime: int
+
+    def __contains__(self, field_value: "FieldElement") -> bool:
+        # called whenever you do: <FieldElement> in <PrimeGaloisField>
+        return 0 <= field_value.value < self.prime
+
+class FieldElement(NamedTuple):
+    value: int
+    field: PrimeGaloisField
+
+    def __repr__(self):
+        return "0x" + f"{self.value:x}".zfill(64)
+        
+    @property
+    def P(self) -> int:
+        return self.field.prime
+    
+    def __add__(self, other: "FieldElement") -> "FieldElement":
+        return FieldElement(
+            value=(self.value + other.value) % self.P,
+            field=self.field
+        )
+    
+    def __sub__(self, other: "FieldElement") -> "FieldElement":
+        return FieldElement(
+            value=(self.value - other.value) % self.P,
+            field=self.field
+        )
+
+    def __rmul__(self, scalar: int) -> "FieldElement":
+        return FieldElement(
+            value=(self.value * scalar) % self.P,
+            field=self.field
+        )
+
+    def __mul__(self, other: "FieldElement") -> "FieldElement":
+        return FieldElement(
+            value=(self.value * other.value) % self.P,
+            field=self.field
+        )
+        
+    def __pow__(self, exponent: int) -> "FieldElement":
+        return FieldElement(
+            value=_mod_pow(self.value, exponent, self.P),
+            field=self.field
+        )
+
+    def __truediv__(self, other: "FieldElement") -> "FieldElement":
+        other_inv = other ** -1
+        return self * other_inv
+
+class EllipticCurve(NamedTuple):
+    a: FieldElement
+    b: FieldElement
+
+    @property
+    def field(self):
+        assert self.a.field == self.b.field
+        return self.a.field
+    
+    def __contains__(self, point: "Point") -> bool:
+        x, y = point.x, point.y
+        return y ** 2 == x ** 3 + self.a * x + self.b
+
+class Point():
+    def __init__(self, x: int, y: int, curve: EllipticCurve):
+        # Encapsulate int coordinates in FieldElement
+        self.x = None if x is None else FieldElement(x, curve.field)
+        self.y = None if y is None else FieldElement(y, curve.field)
+        self.curve = curve
+
+        # Ignore validation for I
+        if self.x is None and self.y is None:
+            return
+
+        # Verify if the point satisfies the curve equation
+        if self not in self.curve:
+            raise ValueError
+
+    def __eq__(self, other):
+        return isinstance(other, Point) and (self.x, self.y, self.curve) == (other.x, other.y, other.curve)
+
+    def __hash__(self):
+        return hash((self.x, self.y, self.curve))
+
+    def __add__(self, other):
+        #################################################################
+        # Point Addition for P₁ or P₂ = I   (identity)                  #
+        #                                                               #
+        # Formula:                                                      #
+        #     P + I = P                                                 #
+        #     I + P = P                                                 #
+        #################################################################
+        if self == secp256r1_I:
+            return other
+
+        if other == secp256r1_I:
+            return self
+
+        #################################################################
+        # Point Addition for X₁ = X₂   (additive inverse)               #
+        #                                                               #
+        # Formula:                                                      #
+        #     P + (-P) = I                                              #
+        #     (-P) + P = I                                              #
+        #################################################################
+        if self.x == other.x and self.y == (-1 * other.y):
+            return secp256r1_I
+
+        #################################################################
+        # Point Addition for X₁ ≠ X₂   (line with slope)                #
+        #                                                               #
+        # Formula:                                                      #
+        #     S = (Y₂ - Y₁) / (X₂ - X₁)                                 #
+        #     X₃ = S² - X₁ - X₂                                         #
+        #     Y₃ = S(X₁ - X₃) - Y₁                                      #
+        #################################################################
+        if self.x != other.x:
+            x1, x2 = self.x, other.x
+            y1, y2 = self.y, other.y
+
+            s = (y2 - y1) / (x2 - x1)
+            x3 = s ** 2 - x1 - x2
+            y3 = s * (x1 - x3) - y1
+
+            return self.__class__(
+                x=x3.value,
+                y=y3.value,
+                curve=secp256r1
+            )
+
+        #################################################################
+        # Point Addition for P₁ = P₂   (vertical tangent)               #
+        #                                                               #
+        # Formula:                                                      #
+        #     S = ∞                                                     #
+        #     (X₃, Y₃) = I                                              #
+        #################################################################
+        if self == other and self.y == float("inf"):
+            return secp256r1_I
+
+        #################################################################
+        # Point Addition for P₁ = P₂   (tangent with slope)             #
+        #                                                               #
+        # Formula:                                                      #
+        #     S = (3X₁² + a) / 2Y₁         .. ∂(Y²) = ∂(X² + aX + b)    #
+        #     X₃ = S² - 2X₁                                             #
+        #     Y₃ = S(X₁ - X₃) - Y₁                                      #
+        #################################################################
+        if self == other:
+            x1, y1, a = self.x, self.y, self.curve.a
+
+            s = (3 * x1 ** 2 + a) / (2 * y1)
+            x3 = s ** 2 - 2 * x1
+            y3 = s * (x1 - x3) - y1
+
+            return self.__class__(
+                x=x3.value,
+                y=y3.value,
+                curve=secp256r1
+            )
+
+        assert False
+
+    def __rmul__(self, scalar: int) -> "Point":
+        # Naive approach:
+        #
+        # result = I
+        # for _ in range(scalar):  # or range(scalar % N)
+        #     result = result + self
+        # return result
+        
+        # Optimized approach using binary expansion
+        current = self
+        result = secp256r1_I
+        while scalar:
+            if scalar & 1:  # same as scalar % 2
+                result = result + current
+            current = current + current  # point doubling
+            scalar >>= 1  # same as scalar / 2
+        return result
+
+class PrivateKey(NamedTuple):
+    secret: int
+    
+    def public_key(self):
+        return self.secret * secp256r1_G
+
+PublicKey = Point
+
+secp256r1_field = PrimeGaloisField(prime=0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff)
+secp256r1 = EllipticCurve(
+    a=FieldElement(0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc, secp256r1_field),
+    b=FieldElement(0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b, secp256r1_field)
+)
+
+secp256r1_G = Point(
+    x=0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296,
+    y=0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5,
+    curve=secp256r1
+)
+
+secp256r1_I = Point(x=None, y=None, curve=secp256r1)
+
+# Order of the group generated by G, such that nG = I
+secp256r1_N = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551
+
+def gen_key() -> PrivateKey:
+    """
+    Creates a new private key. The public key can be derived from this.
+    """
+    return PrivateKey(randint(0, secp256r1_N))
+
+def get_private_bytes(private_key: PrivateKey) -> bytes:
+    """
+    Returns the raw byte representation of `private_key`.
+    See file header for encoding details.
+    """
+    return private_key.secret.to_bytes(32, 'big')
+
+def get_public_bytes(public_key: Point) -> bytes:
+    """
+    Returns the raw byte representation of `public_key`.
+    See file header for encoding details.
+    """
+    return public_key.x.value.to_bytes(32, 'big') + public_key.y.value.to_bytes(32, 'big')
+
+def load_private_key(private_bytes: bytes) -> PrivateKey:
+    """
+    Loads a private key object from the raw representation in `private_bytes`.
+    See file header for encoding details.
+    """
+    assert len(private_bytes) == 32
+    private_value = int.from_bytes(private_bytes, 'big')
+    return PrivateKey(private_value)
+
+def load_public_key(public_bytes: bytes) -> PublicKey:
+    """
+    Loads a public key object from the raw representation in `public_bytes`.
+    See file header for encoding details.
+    """
+    assert len(public_bytes) == 64
+    x_int = int.from_bytes(public_bytes[:32], 'big')
+    y_int = int.from_bytes(public_bytes[32:], 'big')
+    return Point(x_int, y_int, secp256r1)
+
+def _sha256(data: bytes):
+    alg = hashlib.sha256()
+    alg.update(data)
+    return int.from_bytes(alg.digest(), 'big')
+
+def sign(private_key: PrivateKey, data: bytes) -> bytes:
+    z = _sha256(data)
+
+    e = private_key.secret
+    k = randint(0, secp256r1_N)
+    R = k * secp256r1_G
+    r = R.x.value
+    k_inv = _mod_pow(k, -1, secp256r1_N)
+    s = ((z + r*e) * k_inv) % secp256r1_N
+    
+    return r.to_bytes(32, 'big') + s.to_bytes(32, 'big')
+    
+def verify(public_key: Point, signature: bytes, data: bytes) -> bool:
+    z = _sha256(data)
+    r = int.from_bytes(signature[:32], 'big')
+    s = int.from_bytes(signature[32:], 'big')
+
+    s_inv = _mod_pow(s, -1, secp256r1_N)
+    u = (z * s_inv) % secp256r1_N
+    v = (r * s_inv) % secp256r1_N
+    
+    if (u*secp256r1_G + v*public_key).x.value != r:
+        raise InvalidSignature()
+
+def verify_cert(certificate: bytes, device_public_key: Point, test_mode: bool = False):
+    """
+    Verifies the device certificate cryptographically against the ODrive master
+    key.
+    Format of `certificate` documented at ../README.md#device-certificate
+    """
+    assert len(certificate) == 272, len(certificate)
+
+    message = certificate[:80] + get_public_bytes(device_public_key)
+    verify(load_public_key(certificate[144:208]), certificate[80:144], message)
+
+    message = b'ODrive batch key'.ljust(32, b'\0') + certificate[144:208]
+    verify(test_master_key if test_mode else master_key, certificate[208:272], message)
+
+def b64encode(buf: bytes) -> str:
+    return base64.b64encode(buf).decode('utf-8')
+
+def b64decode(buf: str) -> bytes:
+    return base64.b64decode(buf.encode('utf-8'))
+
+def safe_b64encode(buf: bytes) -> str:
+    return base64.urlsafe_b64encode(buf).decode('utf-8').rstrip('=')
+
+def safe_b64decode(buf: str) -> bytes:
+    return base64.urlsafe_b64decode((buf + "=" * (-len(buf) % 4)).encode('utf-8'))
+
+master_key = load_public_key(bytes([
+    0x60, 0xea, 0x3e, 0x6d, 0xc1, 0x18, 0xa2, 0x1f,
+    0x3a, 0x61, 0x99, 0x0c, 0x61, 0x6e, 0xe4, 0x4a,
+    0x02, 0x68, 0x80, 0xa2, 0x5c, 0x70, 0x21, 0xac,
+    0x6c, 0x63, 0x0b, 0x75, 0x39, 0x9b, 0x1b, 0xe2,
+    0x7c, 0xd1, 0x34, 0xc5, 0xd4, 0xf2, 0xa9, 0x1e,
+    0x0b, 0x23, 0x3a, 0x18, 0xb6, 0x43, 0xd5, 0x49,
+    0x7a, 0xd9, 0xe9, 0x3b, 0x8a, 0x52, 0xfe, 0x92,
+    0x95, 0x06, 0xcd, 0x46, 0x18, 0xcf, 0x4c, 0x59
+]))
+
+test_master_key_private = load_private_key(bytes([
+    0xa9, 0x6a, 0x76, 0xd7, 0x54, 0x53, 0x2e, 0x2a,
+    0x38, 0x7a, 0xc5, 0x54, 0x16, 0x53, 0x70, 0xf3,
+    0x48, 0x84, 0x9a, 0xf1, 0x82, 0x11, 0xbf, 0xd2,
+    0x1f, 0x3c, 0x05, 0xf7, 0xf3, 0xeb, 0xef, 0x08
+]))
+
+test_master_key = test_master_key_private.public_key()

odrive/data/brakeRs.json

@@ -0,0 +1,18 @@
+{
+    "50w2rj": {
+        "resistance": 2,
+        "power_rating": 50
+    },
+    "500w2rj": {
+        "resistance": 2,
+        "power_rating": 500
+    },
+    "300w2rj": {
+        "resistance": 2,
+        "power_rating": 300
+    },
+    "625w1r": {
+        "resistance": 1,
+        "power_rating": 625
+    }
+}

odrive/data/drvs.json

@@ -0,0 +1,82 @@
+{
+    "drv8301": {
+        "faults": [
+            [0, "FETLC_OC"],
+            [1, "FETHC_OC"],
+            [2, "FETLB_OC"],
+            [3, "FETHB_OC"],
+            [4, "FETLA_OC"],
+            [5, "FETHA_OC"],
+            [6, "OTW"],
+            [7, "OTSD"],
+            [8, "PVDD_UV"],
+            [9, "GVDD_UV"],
+            [10, "FAULT"],
+            [23, "GVDD_OV"]
+        ],
+        "config": []
+    },
+    "drv8353": {
+        "faults": [
+            [10, "FAULT"],
+            [9, "VDS_OCP"],
+            [8, "GDF"],
+            [7, "UVLO"],
+            [6, "OTSD"],
+            [5, "VDS_HA"],
+            [4, "VDS_LA"],
+            [3, "VDS_HB"],
+            [2, "VDS_LB"],
+            [1, "VDS_HC"],
+            [0, "VDS_LC"],
+            [26, "SA_OC"],
+            [25, "SB_OC"],
+            [24, "SC_OC"],
+            [23, "OTW"],
+            [22, "GDUV"],
+            [21, "VGS_HA"],
+            [20, "VGS_LA"],
+            [19, "VGS_HB"],
+            [18, "VGS_LB"],
+            [17, "VGS_HC"],
+            [16, "VGS_LC"]
+        ],
+        "config": [
+            {"name": "IDRIVEN_HS", "pos": 11, "mask": 15, "codes": ["100mA", "100mA", "200mA", "300mA", "600mA", "700mA", "800mA", "900mA", "1100mA", "1200mA", "1300mA", "1400mA", "1700mA", "1800mA", "1900mA", "2000mA"]},
+            {"name": "IDRIVEP_HS", "pos": 15, "mask": 15, "codes": ["50mA", "50mA", "100mA", "150mA", "300mA", "350mA", "400mA", "450mA", "550mA", "600mA", "650mA", "700mA", "850mA", "900mA", "950mA", "1000mA"]},
+            {"name": "IDRIVEN_LS", "pos": 22, "mask": 15, "codes": ["100mA", "100mA", "200mA", "300mA", "600mA", "700mA", "800mA", "900mA", "1100mA", "1200mA", "1300mA", "1400mA", "1700mA", "1800mA", "1900mA", "2000mA"]},
+            {"name": "IDRIVEP_LS", "pos": 26, "mask": 15, "codes": ["50mA", "50mA", "100mA", "150mA", "300mA", "350mA", "400mA", "450mA", "550mA", "600mA", "650mA", "700mA", "850mA", "900mA", "950mA", "1000mA"]},
+            {"name": "VDS_LVL", "pos": 33, "mask": 15, "codes": ["0.06V", "0.07V", "0.08V", "0.09V", "0.1V", "0.2V", "0.3V", "0.4V", "0.5V", "0.6V", "0.7V", "0.8V", "0.9V", "1.0V", "1.5V", "2.0V"]},
+            {"name": "DEAD_TIME", "pos": 41, "mask": 3, "codes": ["50ns", "100ns", "200ns", "400ns"]},
+            {"name": "SEN_LVL", "pos": 44, "mask": 3, "codes": ["0.25V", "0.5V", "0.75V", "1.0V"]}
+        ]
+    },
+    "drv8316": {
+        "faults": [
+            [6, "BK_FLT"],
+            [5, "SPI_FLT"],
+            [4, "OCP"],
+            [3, "NPOR"],
+            [2, "OVP"],
+            [1, "OT"],
+            [0, "FAULT"],
+            [15, "OTW"],
+            [14, "OTS"],
+            [13, "OCP_HC"],
+            [12, "OCL_LC"],
+            [11, "OCP_HB"],
+            [10, "OCP_LB"],
+            [9, "OCP_HA"],
+            [8, "OCP_LA"],
+            [22, "OTP_ERR"],
+            [21, "BUCK_OCP"],
+            [20, "BUCK_UV"],
+            [19, "VCP_UV"],
+            [18, "SPI_PARITY"],
+            [17, "SPI_SCLK_FLT"],
+            [16, "SPI_ADDR_FLT"]
+        ],
+        "config": [
+        ]
+    }
+}

odrive/data/encoders.json

@@ -0,0 +1,86 @@
+{
+    "AMT10x": {
+        "type": "incremental",
+        "cpr": 8192,
+        "max_rpm": 7500,
+        "datasheet_url": "https://www.cuidevices.com/product/resource/amt10.pdf",
+        "show_in_gui": true,
+        "image": "AMT10.jpeg",
+        "shop_url": "https://odriverobotics.com/shop/cui-amt-102"
+    },
+    "AMT10Ex": {
+        "type": "incremental",
+        "cpr": 20480,
+        "max_rpm": 3000,
+        "datasheet_url": "https://www.cuidevices.com/product/resource/amt10e.pdf",
+        "show_in_gui": true,
+        "image": "AMT10.jpeg",
+        "shop_url": "https://odriverobotics.com/shop/20480-cpr-encoder-with-odrive-cable"
+    },
+    "AMT21xA": {
+        "type": "rs485",
+        "protocol": "AMT21_POLLING",
+        "datasheet_url": "https://www.cuidevices.com/product/resource/amt21.pdf",
+        "cpr": 4096,
+        "max_rpm": 8000,
+        "show_in_gui": false
+    },
+    "AMT21xB": {
+        "type": "rs485",
+        "protocol": "AMT21_POLLING",
+        "datasheet_url": "https://www.cuidevices.com/product/resource/amt21.pdf",
+        "cpr": 16384,
+        "max_rpm": 4000,
+        "show_in_gui": true,
+        "image": "AMT212x-V.jpeg"
+    },
+    "AMT21xB-V-OD": {
+        "type": "rs485",
+        "protocol": "AMT21_EVENT_DRIVEN",
+        "datasheet_url": "https://www.cuidevices.com/product/resource/amt21.pdf",
+        "cpr": 16384,
+        "max_rpm": 6000,
+        "show_in_gui": true,
+        "image": "AMT212x-V.jpeg",
+        "shop_url": "https://odriverobotics.com/shop/cui-amt212b-v-od"
+    },
+    "AMT21xC": {
+        "type": "rs485",
+        "protocol": "AMT21_POLLING",
+        "datasheet_url": "https://www.cuidevices.com/product/resource/amt21.pdf",
+        "cpr": 4096,
+        "max_rpm": 8000,
+        "show_in_gui": false
+    },
+    "AMT21xD": {
+        "type": "rs485",
+        "protocol": "AMT21_POLLING",
+        "datasheet_url": "https://www.cuidevices.com/product/resource/amt21.pdf",
+        "cpr": 16384,
+        "max_rpm": 4000,
+        "show_in_gui": false
+    },
+    "JKongMotor-encoder": {
+        "type": "incremental",
+        "datasheet_url": "https://jkongmotor.en.alibaba.com/product/60286588137-800888379/JK86BLS125_48V_3000RPM_660W_BLDC_MOTOR.html",
+        "cpr": 10000,
+        "max_rpm": 3000,
+        "show_in_gui": false
+    },
+    "KingKong-MBS": {
+        "type": "rs485",
+        "protocol": "MBS",
+        "cpr": 16384,
+        "max_rpm": 20000,
+        "show_in_gui": false
+    },
+    "ODrive-OA1": {
+        "type": "rs485",
+        "protocol": "ODRIVE_OA1",
+        "cpr": 4096,
+        "max_rpm": 60000,
+        "show_in_gui": true,
+        "image": "odrive-mag-encoder.jpeg",
+        "shop_url": "https://odriverobotics.com/shop/odrive-rs485-magnetic-encoder"
+    }
+}

odrive/data/motors.json

@@ -0,0 +1,128 @@
+{
+    "D5065-270KV": {
+        "phase_resistance": 0.039,
+        "phase_inductance": 1.57e-05,
+        "pole_pairs": 7,
+        "max_current": 65,
+        "kv": 270,
+        "moment_of_inertia": 1e-4,
+        "thermistor_r25": 10000,
+        "thermistor_beta": 3435,
+        "max_temp": 130,
+        "shop_url": "https://odriverobotics.com/shop/odrive-custom-motor-d5065",
+        "show_in_gui": true
+    },
+    "D6374-150KV": {
+        "phase_resistance": 0.039,
+        "phase_inductance": 2.40e-05,
+        "pole_pairs": 7,
+        "max_current": 70,
+        "kv": 150,
+        "moment_of_inertia": 1e-4,
+        "thermistor_r25": 10000,
+        "thermistor_beta": 3435,
+        "max_temp": 130,
+        "shop_url": "https://odriverobotics.com/shop/odrive-custom-motor-d6374-150kv",
+        "show_in_gui": true
+    },
+    "D5312s-330KV": {
+        "phase_resistance": 0.037,
+        "phase_inductance": 2.274e-05,
+        "pole_pairs": 7,
+        "max_current": 40,
+        "kv": 330,
+        "thermistor_r25": 10000,
+        "thermistor_beta": 3435,
+        "max_temp": 130,
+        "shop_url": "https://odriverobotics.com/shop/dual-shaft-motor-d5212s-300kv",
+        "show_in_gui": true
+    },
+    "M8325s-100KV": {
+        "phase_resistance": 0.024,
+        "phase_inductance": 9.97e-06,
+        "pole_pairs": 20,
+        "max_current": 50,
+        "kv": 100,
+        "thermistor_r25": 10000,
+        "thermistor_beta": 3435,
+        "max_temp": 130,
+        "shop_url": "https://odriverobotics.com/shop/m8325s",
+        "show_in_gui": true
+    },
+    "BotWheel": {
+        "phase_resistance": 0.8,
+        "phase_inductance": 1.7e-03,
+        "pole_pairs": 15,
+        "max_current": 16,
+        "kv": 8.7,
+        "thermistor_r25": 20000,
+        "thermistor_beta": 3950,
+        "max_temp": 130,
+        "shop_url": "https://odriverobotics.com/shop/botwheels",
+        "show_in_gui": true,
+        "builtin_inc_cpr": 3200,
+        "builtin_hall": true
+    },
+    "Herlea Pancake": {
+        "phase_resistance": 0.0463,
+        "phase_inductance": 3.22e-5,
+        "pole_pairs": 20,
+        "max_current": 50,
+        "kv": 120,
+        "show_in_gui": false
+    },
+    "ME1114": {
+        "phase_resistance": 0.033,
+        "phase_inductance": 1.80e-5,
+        "pole_pairs": 4,
+        "max_current": 200,
+        "calibration_current": 16,
+        "torque_constant": 0.12,
+        "max_vel": 83.33333333333333,
+        "show_in_gui": false
+    },
+    "NEMA34-JKongMotor": {
+        "phase_resistance": 0.0623,
+        "phase_inductance": 9.068e-5,
+        "pole_pairs": 4,
+        "max_current": 20,
+        "torque_constant": 0.13,
+        "thermistor_r25": 10000,
+        "thermistor_beta": 3435,
+        "max_temp": 140,
+        "show_in_gui": false
+    },
+    "NEMA34-Leison": {
+        "phase_resistance": 0.0623,
+        "phase_inductance": 9.068e-5,
+        "pole_pairs": 4,
+        "kv": 87,
+        "max_current": 20,
+        "thermistor_r25": 10000,
+        "thermistor_beta": 3435,
+        "max_temp": 140,
+        "show_in_gui": false
+    },
+    "NEMA32-Leison": {
+        "phase_resistance": 0.1505899578332901,
+        "phase_inductance": 0.00010684521112125367,
+        "pole_pairs": 4,
+        "kv": 145,
+        "max_current": 8,
+        "thermistor_r25": 10000,
+        "thermistor_beta": 3435,
+        "max_temp": 140,
+        "show_in_gui": false
+    },
+    "NEMA23-Leison": {
+        "phase_resistance": 0.147,
+        "phase_inductance": 107.1e-6,
+        "pole_pairs": 4,
+        "kv": 180.5,
+        "max_current": 10,
+        "thermistor_r25": 10000,
+        "thermistor_beta": 3435,
+        "max_temp": 140,
+        "show_in_gui": false
+    }
+}