Test-stands progress.

2 versions for 1 and 2 motors.
Parts for GM6208.

controller/fw/embed/src/main.cpp

@@ -37,8 +37,8 @@ void setup_foc(MagneticSensorAS5045 *sensor, BLDCMotor *motor, DRV8313Driver *dr
     sensor->init(&spi);
     motor->linkSensor(sensor);
     driver->pwm_frequency = 20000;
-    driver->voltage_power_supply = 20;
+    driver->voltage_power_supply = 24;
-    driver->voltage_limit = 40;
+    driver->voltage_limit = 24;
     driver->init();
     motor->linkDriver(driver);
     current_sense->linkDriver(driver);
@@ -50,6 +50,7 @@ void setup_foc(MagneticSensorAS5045 *sensor, BLDCMotor *motor, DRV8313Driver *dr
     motor->monitor_start_char = 'M';
     motor->monitor_end_char = 'M';
     commander->verbose = VerboseMode::machine_readable;
+    motor->monitor_downsample = 5000;
     motor->controller = MotionControlType::angle;
     motor->torque_controller = TorqueControlType::voltage;
     motor->foc_modulation = FOCModulationType::SinePWM;

controller/fw/embed/test/README

@@ -1,11 +0,0 @@
-
-This directory is intended for PlatformIO Test Runner and project tests.
-
-Unit Testing is a software testing method by which individual units of
-source code, sets of one or more MCU program modules together with associated
-control data, usage procedures, and operating procedures, are tested to
-determine whether they are fit for use. Unit testing finds problems early
-in the development cycle.
-
-More information about PlatformIO Unit Testing:
-- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html

controller/fw/embed/test/README.md

@@ -0,0 +1,86 @@
+# CAN Communication Scripts
+
+This repository contains Python scripts for testing and interacting with a CAN bus system. These scripts enable sending and receiving CAN messages to control a motor, set angles, and adjust velocities.
+
+## Prerequisites
+
+1. **Python 3.7+** installed on your system.
+2. **`python-can` library** installed. Install it via pip:
+   ```bash
+   pip install python-can
+   ```
+3. **SocketCAN interface** properly configured on your Linux system. The default channel is `can0`.
+
+## Usage
+
+### 1. Receiving CAN Messages
+
+The script `python_can.py` listens to the CAN bus and processes incoming messages.
+
+#### Run:
+```bash
+python3 python_can.py
+```
+
+#### Features:
+- Processes messages with data length 5.
+- Parses the first byte (`flag`) to determine the type:
+  - `'A'`: Angle (float).
+  - `'V'`: Velocity (float).
+  - `'E'`: Enable/disable status (boolean).
+
+### 2. Enabling or Disabling the Motor
+
+The script `python_enable_motor.py` sends commands to enable or disable the motor.
+
+#### Run:
+```bash
+python3 python_enable_motor.py <0|1>
+```
+
+#### Arguments:
+- `0`: Disable the motor.
+- `1`: Enable the motor.
+
+### 3. Sending Target Angle
+
+The script `python_send_angle.py` sends a target angle to the CAN bus.
+
+#### Run:
+```bash
+python3 python_send_angle.py
+```
+
+#### Behavior:
+- Sends a message with a predefined target angle every second.
+- Adjust the target angle in the script (`target_angle` variable).
+
+### 4. Sending Target Velocity
+
+The script `python_send_velocity.py` sends a target velocity to the CAN bus.
+
+#### Run:
+```bash
+python3 python_send_velocity.py
+```
+
+#### Behavior:
+- Sends a message with a predefined target velocity every second.
+- Adjust the target velocity in the script (`target_speed` variable).
+
+## Configuration
+
+### CAN Interface
+The scripts use the following default CAN bus settings:
+- **Channel**: `can0`
+- **Bitrate**: `1 Mbps`
+
+If your configuration differs, update the `Bus()` initialization in the scripts.
+
+## Troubleshooting
+
+1. **"Error initializing CAN bus"**:
+   - Ensure your CAN interface is correctly configured and active:
+     ```bash
+     sudo ip link set can0 up type can bitrate 1000000
+     ```

controller/fw/embed/test/python_can.py

@@ -0,0 +1,47 @@
+import can
+import struct
+import time
+
+def process_can_message(msg):
+    if msg.dlc == 5:  # Check the message length
+        print(f"Received message with ID: {msg.arbitration_id}")
+        print(f"Data: {msg.data}")
+
+        # The first byte determines the data type (flag)
+        flag = chr(msg.data[0])
+        
+        if flag == 'A':  # Angle
+            angle_bytes = msg.data[1:5]
+            angle = struct.unpack('<f', bytes(angle_bytes))[0]
+            print(f"Angle: {angle} degrees")
+        elif flag == 'V':  # Velocity
+            velocity_bytes = msg.data[1:5]
+            velocity = struct.unpack('<f', bytes(velocity_bytes))[0]
+            print(f"Velocity: {velocity} rad/s")
+        elif flag == 'E' and msg.dlc >= 2:  # Enable/Disable
+            enabled = msg.data[1]  # Expecting 1 byte (0 or 1)
+            print(f"Enabled: {bool(enabled)}")
+        else:
+            print(f"Unknown flag: {flag}")
+    else:
+        print(f"Received message with unexpected length: {msg.dlc}")
+
+def receive_can_messages():
+    try:
+        # Connect to the CAN bus
+        bus = can.interface.Bus(channel='can0', bustype='socketcan')
+
+        print("Waiting for messages on the CAN bus...")
+
+        while True:
+            msg = bus.recv()
+            if msg:
+                process_can_message(msg)
+
+    except KeyboardInterrupt:
+        print("\nExiting program...")
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == '__main__':
+    receive_can_messages()

controller/fw/embed/test/python_enable_motor.py

@@ -0,0 +1,54 @@
+import can
+import sys
+
+# Function to send the motor enable/disable command
+def send_motor_enable(bus, enable):
+    """
+    Sends a command to enable or disable the motor.
+
+    :param bus: The CAN bus
+    :param enable: 1 to enable the motor, 0 to disable it
+    """
+    msg = can.Message()
+    msg.arbitration_id = 1  # Message ID
+    msg.is_extended_id = False
+    msg.dlc = 2  # Message length (flag + 1 byte of data)
+    msg.data = [ord('E'), enable]  # 'E' for the command, followed by 0 or 1
+
+    try:
+        bus.send(msg)
+        state = "enabled" if enable else "disabled"
+        print(f"Sent message to {state} motor")
+        print(f"Message data: {msg.data}")
+    except can.CanError as e:
+        print(f"Message failed to send: {e}")
+        sys.exit(1)  # Exit the program on failure
+
+def main():
+    # CAN interface setup
+    bus = None  # Define outside the try block for proper shutdown
+    try:
+        bus = can.interface.Bus(channel='can0', bustype='socketcan', bitrate=1000000)  # Ensure the bitrate matches the microcontroller settings
+        print("CAN bus initialized.")
+
+        # Ensure the state is passed via arguments
+        if len(sys.argv) != 2 or sys.argv[1] not in ['0', '1']:
+            print("Usage: python3 script_name.py <0|1>")
+            print("0 - Disable motor, 1 - Enable motor")
+            sys.exit(1)
+
+        enable = int(sys.argv[1])
+        send_motor_enable(bus, enable)
+
+    except Exception as e:
+        print(f"Error initializing CAN bus: {e}")
+        sys.exit(1)
+
+    finally:
+        # Ensure the bus is properly shut down
+        if bus is not None:
+            bus.shutdown()
+            print("CAN bus shut down.")
+
+if __name__ == '__main__':
+    main()

controller/fw/embed/test/python_send_angle.py

@@ -0,0 +1,37 @@
+import can
+import struct
+import time
+import argparse
+
+# Function to send the target angle
+def send_target_angle(bus, target_angle):
+    msg = can.Message()
+    msg.arbitration_id = 1  # Message ID
+    msg.is_extended_id = False
+    msg.dlc = 5  # Message length
+    msg.data = [ord('A')] + list(struct.pack('<f', target_angle))  # 'A' for the command identifier, followed by the angle in float format
+
+    try:
+        bus.send(msg)
+        print(f"Sent message with target angle: {target_angle} degrees")
+        print(f"Message data: {msg.data}")
+    except can.CanError:
+        print("Message failed to send")
+
+# Main function
+def main():
+    parser = argparse.ArgumentParser(description="Send target angles over CAN bus.")
+    parser.add_argument("--angle", type=float, required=True, help="Target angle to send over the CAN bus")
+    args = parser.parse_args()
+
+    target_angle = args.angle
+
+    # CAN interface setup
+    bus = can.interface.Bus(channel='can0', bustype='socketcan', bitrate=1000000)  # Ensure the bitrate matches the microcontroller settings
+    print("CAN bus initialized, sending target angles...")
+
+    # Loop to send messages
+    send_target_angle(bus, target_angle)
+
+if __name__ == '__main__':
+    main()

controller/fw/embed/test/python_send_velocity.py

@@ -0,0 +1,76 @@
+import can
+import struct
+import time
+import sys
+
+# Function to send the target speed
+def send_target_speed(bus, target_speed):
+    msg = can.Message()
+    msg.arbitration_id = 1  # Message ID
+    msg.is_extended_id = False
+    msg.dlc = 5  # Message length
+    msg.data = bytearray([ord('V')] + list(struct.pack('<f', target_speed)))  # 'V' for the command identifier, followed by the speed in float format
+
+    try:
+        bus.send(msg)
+        print(f"Sent message with target speed: {target_speed} rad/s")
+    except can.CanError:
+        print("Message failed to send")
+
+# Function to send the motor enable/disable command
+def send_motor_enable(bus, enable):
+    """
+    Sends a command to enable or disable the motor.
+    
+    :param bus: The CAN bus
+    :param enable: 1 to enable the motor, 0 to disable it
+    """
+    msg = can.Message()
+    msg.arbitration_id = 1  # Message ID
+    msg.is_extended_id = False
+    msg.dlc = 2  # Message length (flag + 1 byte of data)
+    msg.data = bytearray([ord('E'), enable])  # 'E' for the command, followed by 0 or 1
+
+    try:
+        bus.send(msg)
+        state = "enabled" if enable else "disabled"
+        print(f"Sent message to {state} motor")
+    except can.CanError as e:
+        print(f"Message failed to send: {e}")
+        sys.exit(1)  # Exit the program on failure
+
+    send_target_speed(bus,0.0)
+
+def main():
+    # CAN interface setup
+    bus = None  # Define outside the try block for proper shutdown
+    try:
+        bus = can.interface.Bus(channel='COM4', bustype='slcan', bitrate=1000000)  # Ensure the bitrate matches the microcontroller settings
+        print("CAN bus initialized.")
+
+        while True:
+            user_input = input("Enter target speed: ")
+            if user_input.lower() == 'exit':
+                print("Exiting...")
+                break
+            try:
+                target_speed = float(user_input)
+                send_target_speed(bus, target_speed)
+            except ValueError:
+                print("Invalid input. Please enter a valid number.")
+
+        # Disable motor before exiting
+        send_motor_enable(bus, 0)
+        print("Motor disabled.")
+    
+    except Exception as e:
+        print(f"Error initializing1 CAN bus: {e}")
+        sys.exit(1)
+
+    finally:
+        if bus is not None:
+            bus.shutdown()
+            print("CAN bus shut down.")
+
+if __name__ == '__main__':
+    main()

controller/fw/embed/test/send_velocity_impulses.py

@@ -0,0 +1,35 @@
+import can
+import struct
+import time
+
+# Function to send the target speed
+def send_target_speed(bus, target_speed):
+    msg = can.Message()
+    msg.arbitration_id = 1  # Message ID
+    msg.is_extended_id = False
+    msg.dlc = 5  # Message length
+    msg.data = [ord('V')] + list(struct.pack('<f', target_speed))  # 'V' for the command identifier, followed by the speed in float format
+
+    try:
+        bus.send(msg)
+        print(f"Sent message with target speed: {target_speed} m/s")
+        print(f"Message data: {msg.data}")
+    except can.CanError:
+        print("Message failed to send")
+
+# Main function
+def main():
+    # CAN interface setup
+    bus = can.interface.Bus(channel='can0', bustype='socketcan', bitrate=1000000)  # Ensure the bitrate matches the microcontroller settings
+    print("CAN bus initialized, sending target speed impulses...")
+
+    # Send impulses of target speed from -2 to 2 m/s
+    target_speeds = [-1, 1]
+
+    while True:
+        for speed in target_speeds:
+            send_target_speed(bus, speed)
+            time.sleep(1)  # 1-second delay between messages
+
+if __name__ == '__main__':
+    main()

controller/hw/motor_controller_50mm.kicad_prl

@@ -67,7 +67,7 @@
       39,
       40
     ],
-    "visible_layers": "0001010_00000001",
+    "visible_layers": "0001010_80000000",
     "zone_display_mode": 0
   },
   "git": {