verilog_data-2 / ExcessiveMotion_controller-software /controller-software /config /electrical /connectors.py
| from dataclasses import dataclass, field, asdict, is_dataclass, fields | |
| from enum import Enum, auto | |
| from typing import List, Any | |
| class CONNECTOR_TYPES(Enum): | |
| # Motors | |
| MOTOR_PMSM = auto() | |
| MOTOR_DC = auto() | |
| MOTOR_STEPPER_BIPOLAR = auto() | |
| MOTOR_STEPPER_UNIPOLAR = auto() | |
| MOTOR_INDUCTION = auto() | |
| # Drives | |
| DRIVE_PMSM = auto() | |
| DRIVE_DC = auto() | |
| DRIVE_STEPPER_BIPOLAR = auto() | |
| DRIVE_STEPPER_UNIPOLAR = auto() | |
| DRIVE_INDUCTION = auto() | |
| # Power sources | |
| POWER_DC = auto() | |
| POWER_AC1 = auto() | |
| POWER_AC3 = auto() | |
| # IO | |
| OUTPUT_DIGITAL_DC = auto() | |
| INPUT_DIGITAL_DC = auto() | |
| OUTPUT_ANALOG = auto() | |
| INPUT_ANALOG = auto() | |
| # Communication | |
| EM_SERIAL_485 = auto() | |
| EM_SERIAL_422 = auto() | |
| # Safety | |
| STO_2 = auto() # 2 ch sto with feedback | |
| ANY = auto() | |
| class CONNECTOR: | |
| description: str = field(default="Default description", metadata={'desc': 'What is connected to the motor connector'}) | |
| required: bool = field(default=False, metadata={'desc': 'Is the connector required to be connected'}) | |
| exclusive: bool = field(default=False, metadata={'desc': 'Only allowed to connect to a single other connector (no branches)'}) | |
| enabled: bool = field(default=False, metadata={'desc': 'Is the connector required to be connected'}) | |
| direction: str = field(default="input", metadata={'desc': 'Typical direction of the connection (input/output/bidirectional)'}) | |
| can_connect_to: list = field(default_factory=list, metadata={'desc': 'List of connectors that this connector can connect to'}) | |
| is_connected_to: list = field(default_factory=list, metadata={'desc': 'List of connectors that this connector is connected to'}) | |
| hardware_identifier: str = field(default="None", metadata={'desc': 'ID of connector on hardware'}) | |
| type: CONNECTOR_TYPES = field(default=CONNECTOR_TYPES.ANY, metadata={'desc': 'Type of connector'}) | |
| parent: Any = field(default=None, repr=False, compare=False, metadata={'exclude': True}) | |
| class CONNECTOR_FUNCTIONS: | |
| def validate_connect_to(own_connector: CONNECTOR, external_connectors: list[CONNECTOR]): | |
| if own_connector not in own_connector.parent.connectors.values(): | |
| raise ValueError(f'Connector not found in device ({own_connector.description})') | |
| if not own_connector.enabled: | |
| return [False, "Source connector is disabled"] | |
| if own_connector.exclusive and len(external_connectors) > 1: | |
| return [False, "Source connector can't connect to multiple connectors"] | |
| for external_connector in external_connectors: | |
| if own_connector == external_connector: | |
| return [False, "Source connector can't connect to itself"] | |
| if external_connector in own_connector.is_connected_to or own_connector in external_connector.is_connected_to: | |
| if not external_connector in own_connector.is_connected_to or not own_connector in external_connector.is_connected_to: | |
| return [False, "Connections between devices are not synced"] # TODO: handle this case better | |
| return [False, "Source connector is already connected to target connector"] | |
| if not external_connector.enabled: | |
| return [False, "Source connector is disabled"] | |
| if external_connector.exclusive and len(external_connectors) > 1: | |
| return [False, f"Target connector ({external_connector.description}) can't connect to multiple connectors"] | |
| if external_connector.type not in own_connector.can_connect_to: | |
| return [False, f"Target connector type mismatch, {own_connector.description} can't connect to {external_connector.type}"] | |
| if own_connector.exclusive: | |
| if own_connector.direction == "input" and external_connector.direction == "input": | |
| return [False, "Source connector is an input and target connector is an input, one must be an output"] | |
| elif own_connector.direction == "output" and external_connector.direction == "output": | |
| return [False, "Source connector is an output and target connector is an output, one must be an input"] | |
| return [True, ""] | |
| def connect_to(own_connector: CONNECTOR, external_connectors: list[CONNECTOR]): | |
| success, error = CONNECTOR_FUNCTIONS.validate_connect_to(own_connector, external_connectors) | |
| if not success: | |
| return [False, f"Connector validation failed ({error})"] | |
| for external_connector in external_connectors: | |
| own_connector.is_connected_to.append(external_connector) | |
| external_connector.is_connected_to.append(own_connector) | |
| return [True, ""] | |
| def disconnect_from(own_connector: CONNECTOR, external_connectors: list[CONNECTOR]): | |
| error = "" | |
| for external_connector in external_connectors: | |
| if external_connector in own_connector.is_connected_to: | |
| own_connector.is_connected_to.remove(external_connector) | |
| else: | |
| error += f"Connector {own_connector.description} is not connected to {external_connector.description}, nothing to disconnect\n" | |
| if own_connector in external_connector.is_connected_to: | |
| external_connector.is_connected_to.remove(own_connector) | |
| else: | |
| error += f"Connector {external_connector.description} is not connected to {own_connector.description}, nothing to disconnect\n" | |
| if error != "": | |
| return [False, error] | |
| return [True, ""] | |
| def update_from_connector(own_connector: CONNECTOR, external_connector: CONNECTOR = None): | |
| if external_connector is None and len(own_connector.is_connected_to) > 1: | |
| return [False, "Multiple connections, please specify external connector to update from"] | |
| if own_connector not in own_connector.parent.connectors.values(): | |
| raise ValueError(f'Connector not found in device ({external_connector.parent.module_type}/{own_connector.description})') | |
| if len(own_connector.is_connected_to) == 0: | |
| return [False, "Connector is not connected to anything"] | |
| update_count = 0 | |
| if external_connector.parent.module_type == "motor": | |
| for own_param in fields(own_connector.parent.common_params): | |
| own_param_name = own_param.name | |
| own_param_data = getattr(own_connector.parent.common_params, own_param_name) | |
| if own_param_data.auto_fill_enable: | |
| for auto_fill_source in own_param_data.auto_fill_by: | |
| for external_param in fields(external_connector.parent.common_params): | |
| external_param_name = external_param.name | |
| if auto_fill_source == external_param_name: | |
| getattr(own_connector.parent.common_params, own_param_name).value = getattr(external_connector.parent.common_params, auto_fill_source).value | |
| update_count += 1 | |
| print(f"Updated {own_param_name} to {getattr(own_connector.parent.common_params, own_param_name).value}") | |
| else: | |
| return [False, "Cannot auto update from type: " + external_connector.parent.module_type] | |
| if update_count == 1: | |
| return [True, f"{update_count} value updated"] | |
| return [True, f"{update_count} values updated"] | |