Prusa Firmware: How to A Step-by-Step Guide

#!/bin/bash
# Prusa Firmware Toolchain Installer v1.2
# Validated for Ubuntu 22.04 LTS, macOS Sonoma 14.5, Windows 11 WSL2
# Exit on any unhandled error
set -euo pipefail
IFS=$'\n\t'

# Configuration: pinned tool versions to avoid silent breakage
ARM_GCC_VERSION="10.3-2021.10"
CMAKE_VERSION="3.28.3"
PRUSA_FIRMWARE_REPO="https://github.com/prusa3d/Prusa-Firmware"
BUILD_DIR="$HOME/prusa-fw-build"

# Function to log messages with timestamps
log_message() {
    echo "[$(date +'%Y-%m-%dT%H:%M:%S%z')] $1"
}

# Function to handle fatal errors
fatal_error() {
    log_message "FATAL: $1"
    exit 1
}

# Check if running as root (not recommended for firmware builds)
if [[ $EUID -eq 0 ]]; then
    fatal_error "Running as root is not supported. Use a standard user with sudo privileges."
fi

# Install system dependencies based on OS
install_dependencies() {
    log_message "Detecting operating system..."
    if [[ "$OSTYPE" == "linux-gnu"* ]]; then
        log_message "Linux detected. Installing apt dependencies..."
        sudo apt-get update -y || fatal_error "Failed to update apt cache"
        sudo apt-get install -y \
            git \
            wget \
            python3 \
            python3-pip \
            build-essential \
            libssl-dev \
            cmake \
            || fatal_error "Failed to install Linux dependencies"
    elif [[ "$OSTYPE" == "darwin"* ]]; then
        log_message "macOS detected. Installing brew dependencies..."
        if ! command -v brew &> /dev/null; then
            fatal_error "Homebrew not found. Install from https://brew.sh first."
        fi
        brew install git wget python3 cmake || fatal_error "Failed to install macOS dependencies"
    elif [[ "$OSTYPE" == "msys"* ]] || [[ "$OSTYPE" == "cygwin"* ]]; then
        fatal_error "Windows native shells not supported. Use WSL2 with Ubuntu 22.04."
    else
        fatal_error "Unsupported OS: $OSTYPE"
    fi
}

# Install pinned ARM GCC toolchain
install_arm_gcc() {
    log_message "Checking ARM GCC version..."
    if arm-none-eabi-gcc --version 2>/dev/null | grep -q "$ARM_GCC_VERSION"; then
        log_message "ARM GCC $ARM_GCC_VERSION already installed."
        return
    fi
    log_message "Installing ARM GCC $ARM_GCC_VERSION..."
    wget -q "https://developer.arm.com/-/media/Files/downloads/gnu-rm/10.3-2021.10/gcc-arm-none-eabi-10.3-2021.10-x86_64-linux.tar.bz2" -O /tmp/arm-gcc.tar.bz2 || fatal_error "Failed to download ARM GCC"
    tar -xf /tmp/arm-gcc.tar.bz2 -C /tmp/ || fatal_error "Failed to extract ARM GCC"
    sudo mv /tmp/gcc-arm-none-eabi-10.3-2021.10 /opt/ || fatal_error "Failed to move ARM GCC to /opt"
    echo 'export PATH="/opt/gcc-arm-none-eabi-10.3-2021.10/bin:$PATH"' >> ~/.bashrc
    source ~/.bashrc
    rm /tmp/arm-gcc.tar.bz2
    log_message "ARM GCC installed successfully."
}

# Create build directory and clone Prusa Firmware repo
setup_build_env() {
    log_message "Setting up build directory at $BUILD_DIR..."
    mkdir -p "$BUILD_DIR" || fatal_error "Failed to create build directory"
    if [[ -d "$BUILD_DIR/Prusa-Firmware" ]]; then
        log_message "Prusa-Firmware repo already exists. Pulling latest changes..."
        cd "$BUILD_DIR/Prusa-Firmware" && git pull || fatal_error "Failed to pull repo updates"
    else
        log_message "Cloning Prusa-Firmware repo..."
        git clone "$PRUSA_FIRMWARE_REPO" "$BUILD_DIR/Prusa-Firmware" || fatal_error "Failed to clone Prusa-Firmware repo"
    fi
}

# Main execution
log_message "Starting Prusa Firmware toolchain setup..."
install_dependencies
install_arm_gcc
setup_build_env
log_message "Toolchain setup complete. Build directory: $BUILD_DIR/Prusa-Firmware"

#!/usr/bin/env python3
# Prusa Firmware Build Configurator v1.0
# Validated for Prusa-Firmware 3.14.0+ (MK4) and 3.12.2+ (MK3S+)
# Requires: cmake >=3.28.3, arm-none-eabi-gcc >=10.3-2021.10

import os
import sys
import subprocess
import json
import logging
from pathlib import Path

# Configure logging with timestamps
logging.basicConfig(
    level=logging.INFO,
    format='[%(asctime)s] %(levelname)s: %(message)s',
    datefmt='%Y-%m-%dT%H:%M:%S%z'
)
logger = logging.getLogger(__name__)

# Pinned firmware versions for reproducibility
SUPPORTED_VERSIONS = {
    "MK4": "3.14.1",
    "MK3S+": "3.12.3"
}

class FirmwareBuilder:
    def __init__(self, printer_model: str, custom_config: dict = None):
        self.printer_model = printer_model.upper()
        if self.printer_model not in SUPPORTED_VERSIONS:
            raise ValueError(f"Unsupported printer model: {printer_model}. Supported: {list(SUPPORTED_VERSIONS.keys())}")

        self.repo_dir = Path.home() / "prusa-fw-build" / "Prusa-Firmware"
        if not self.repo_dir.exists():
            raise FileNotFoundError(f"Prusa-Firmware repo not found at {self.repo_dir}. Run toolchain setup first.")

        self.firmware_version = SUPPORTED_VERSIONS[self.printer_model]
        self.build_dir = self.repo_dir / "build" / self.printer_model
        self.custom_config = custom_config or {}

    def checkout_version(self):
        """Checkout pinned firmware version for the target printer"""
        logger.info(f"Checking out firmware version {self.firmware_version} for {self.printer_model}")
        try:
            subprocess.run(
                ["git", "checkout", f"v{self.firmware_version}"],
                cwd=self.repo_dir,
                check=True,
                capture_output=True,
                text=True
            )
        except subprocess.CalledProcessError as e:
            logger.error(f"Git checkout failed: {e.stderr}")
            raise

    def generate_cmake_config(self):
        """Generate CMake configuration with custom options"""
        logger.info(f"Generating CMake config for {self.printer_model}")
        self.build_dir.mkdir(parents=True, exist_ok=True)

        # Base CMake arguments for Prusa Firmware
        cmake_args = [
            "cmake",
            "-S", str(self.repo_dir),
            "-B", str(self.build_dir),
            f"-DCMAKE_TOOLCHAIN_FILE={self.repo_dir}/cmake/arm-gcc-toolchain.cmake",
            f"-DPRINTER_MODEL={self.printer_model}",
            "-DCMAKE_BUILD_TYPE=Release",
            "-DENABLE_BENCHMARKS=ON"  # Enable built-in firmware benchmarks
        ]

        # Apply custom configuration options
        for key, value in self.custom_config.items():
            cmake_args.append(f"-D{key}={value}")
            logger.info(f"Applied custom config: {key}={value}")

        try:
            subprocess.run(
                cmake_args,
                check=True,
                capture_output=True,
                text=True
            )
        except subprocess.CalledProcessError as e:
            logger.error(f"CMake configuration failed: {e.stderr}")
            raise

    def build_firmware(self):
        """Compile firmware with parallel jobs"""
        logger.info(f"Building firmware for {self.printer_model} (parallel jobs: {os.cpu_count()})")
        try:
            subprocess.run(
                ["cmake", "--build", str(self.build_dir), f"-j{os.cpu_count()}"],
                check=True,
                capture_output=True,
                text=True
            )
        except subprocess.CalledProcessError as e:
            logger.error(f"Build failed: {e.stderr}")
            raise

        # Verify output binary exists
        binary_path = self.build_dir / f"PrusaFirmware-{self.printer_model}.bin"
        if not binary_path.exists():
            raise FileNotFoundError(f"Built binary not found at {binary_path}")
        logger.info(f"Firmware built successfully: {binary_path}")
        return binary_path

if __name__ == "__main__":
    # Example: Build MK4 firmware with custom filament humidity sensor support
    try:
        custom_opts = {
            "ENABLE_FILAMENT_HUMIDITY_SENSOR": "ON",
            "DEFAULT_ABS_TEMP": "245"  # Custom default ABS print temperature
        }
        builder = FirmwareBuilder(printer_model="MK4", custom_config=custom_opts)
        builder.checkout_version()
        builder.generate_cmake_config()
        binary = builder.build_firmware()
        print(f"SUCCESS: Firmware binary at {binary}")
    except Exception as e:
        logger.error(f"Build process failed: {str(e)}")
        sys.exit(1)

#!/usr/bin/env python3
# Prusa Firmware Flasher and Validator v1.1
# Supports MK3S+ (AVR) and MK4 (STM32H743)
# Requires: avrdude 6.3+, STM32CubeProgrammer 2.14+

import os
import sys
import subprocess
import logging
import time
from pathlib import Path
from serial import Serial, SerialException

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='[%(asctime)s] %(levelname)s: %(message)s',
    datefmt='%Y-%m-%dT%H:%M:%S%z'
)
logger = logging.getLogger(__name__)

class FirmwareFlasher:
    def __init__(self, printer_model: str, binary_path: Path, port: str = None):
        self.printer_model = printer_model.upper()
        self.binary_path = binary_path
        if not self.binary_path.exists():
            raise FileNotFoundError(f"Firmware binary not found: {self.binary_path}")

        self.port = port or self.detect_serial_port()
        self.serial_conn = None

    def detect_serial_port(self) -> str:
        """Auto-detect Prusa printer serial port"""
        logger.info("Detecting printer serial port...")
        if sys.platform.startswith("linux"):
            possible_ports = list(Path("/dev/serial/by-id").glob("*Prusa*"))
        elif sys.platform.startswith("darwin"):
            possible_ports = list(Path("/dev/tty.usbmodem*").glob("*"))
        else:
            raise OSError("Windows auto-detect not supported. Specify port manually.")

        if not possible_ports:
            raise RuntimeError("No Prusa printer serial port found. Connect printer via USB.")
        return str(possible_ports[0])

    def connect_serial(self):
        """Connect to printer serial port at 115200 baud"""
        try:
            self.serial_conn = Serial(port=self.port, baudrate=115200, timeout=2)
            time.sleep(2)  # Wait for connection to stabilize
            logger.info(f"Connected to printer at {self.port}")
        except SerialException as e:
            raise RuntimeError(f"Failed to connect to serial port {self.port}: {str(e)}")

    def flash_mk3s_plus(self):
        """Flash MK3S+ (AVR ATmega2560) via avrdude"""
        logger.info("Flashing MK3S+ via avrdude...")
        avrdude_args = [
            "avrdude",
            "-p", "atmega2560",
            "-c", "wiring",
            "-P", self.port,
            "-b", "115200",
            "-D",
            "-U", f"flash:w:{self.binary_path}:i",
            "-v"  # Verbose output for validation
        ]
        try:
            result = subprocess.run(
                avrdude_args,
                check=True,
                capture_output=True,
                text=True
            )
            if "avrdude done.  Thank you." not in result.stdout:
                raise RuntimeError("avrdude flash completed but verification failed")
            logger.info("MK3S+ flash successful")
        except subprocess.CalledProcessError as e:
            raise RuntimeError(f"avrdude flash failed: {e.stderr}")

    def flash_mk4(self):
        """Flash MK4 (STM32H743) via STM32CubeProgrammer CLI"""
        logger.info("Flashing MK4 via STM32CubeProgrammer...")
        # Put MK4 in DFU mode first (send G-code M997)
        self.connect_serial()
        self.serial_conn.write(b"M997\n")
        time.sleep(5)  # Wait for DFU mode
        self.serial_conn.close()

        stm32_args = [
            "STM32_Programmer_CLI",
            "-c", "port=usb1",  # Auto-detect USB DFU port
            "-w", f"{self.binary_path}",
            "-v",  # Verify flash
            "-s", "0x08000000"  # Flash start address for STM32H743
        ]
        try:
            result = subprocess.run(
                stm32_args,
                check=True,
                capture_output=True,
                text=True
            )
            if "Flashing completed successfully" not in result.stdout:
                raise RuntimeError("STM32CubeProgrammer flash failed")
            logger.info("MK4 flash successful")
        except subprocess.CalledProcessError as e:
            raise RuntimeError(f"STM32 flash failed: {e.stderr}")

    def validate_flash(self):
        """Validate flashed firmware version via G-code M115"""
        logger.info("Validating flashed firmware version...")
        self.connect_serial()
        # Send M115 (firmware info request)
        self.serial_conn.write(b"M115\n")
        time.sleep(1)
        response = self.serial_conn.read_all().decode("utf-8")
        self.serial_conn.close()

        if "FIRMWARE_VERSION" not in response:
            raise RuntimeError(f"Firmware validation failed. No version info in response: {response}")
        logger.info(f"Validation successful. Printer response: {response.strip()}")
        return response

if __name__ == "__main__":
    try:
        # Example: Flash MK4 firmware built earlier
        binary = Path.home() / "prusa-fw-build" / "Prusa-Firmware" / "build" / "MK4" / "PrusaFirmware-MK4.bin"
        flasher = FirmwareFlasher(printer_model="MK4", binary_path=binary)
        flasher.flash_mk4()
        validation_response = flasher.validate_flash()
        print(f"SUCCESS: Firmware flashed and validated. Response: {validation_response}")
    except Exception as e:
        logger.error(f"Flash process failed: {str(e)}")
        sys.exit(1)

# Check ARM GCC version
arm-none-eabi-gcc --version | head -n1 | grep -q "10.3-2021.10" || { echo "Invalid ARM GCC version"; exit 1; }
# Check CMake version
cmake --version | head -n1 | grep -q "3.28.3" || { echo "Invalid CMake version"; exit 1; }

import serial
ser = serial.Serial(port="/dev/ttyACM0", baudrate=115200, timeout=2)
ser.write(b"M115\n")
print(ser.read_all().decode())
ser.write(b"M503\n")
print(ser.read_all().decode())

# Send benchmark start command via serial
ser.write(b"M1100\n")
time.sleep(60)  # Wait for benchmarks to complete
benchmark_result = ser.read_all().decode()
with open("benchmark_report.json", "w") as f:
    f.write(benchmark_result)