• Why Use autorandr?
• Prerequisites (Raspberry Pi 4B Specific)
• Installation on openSUSE Tumbleweed
• Basic Configuration: Creating and Managing Profiles
• Applying Configurations
• Automation (Recommended)
• Setting a Default Fallback Profile
• Advanced Usage
• Troubleshooting
• Alternative: Hardware HDMI EDID Emulator
• Resources
• A. monitor-info.sh (Bash script to collect monitor data)
• B. “Improved Temporary Xrandr configuration script”

#Why Use autorandr?

autorandr is a highly effective, Python-based utility specifically designed to automate and simplify the management of multiple display configurations on Linux systems. Its core strength lies in its ability to automatically detect which displays (like projectors, external monitors, or ultrawide screens) are currently connected to your system and then apply a pre-saved configuration (“profile”) that matches that specific hardware setup. This eliminates the need to manually execute commands with xrandr (a command-line tool for configuring display settings) every time you connect or disconnect a display.

This automation is particularly beneficial in your scenario as a professor using a Raspberry Pi 4B with openSUSE Tumbleweed. Imagine moving between different lecture halls, each potentially having a projector with a unique native resolution (1024x768, 1280x800, etc.), then returning to your office to connect to an ultrawide monitor (e.g., 3440x1440), and perhaps later connecting to a standard monitor in a departmental meeting room. Without autorandr, each transition would require manual reconfiguration. With autorandr, once you’ve saved a profile for each setup, the system adapts automatically upon connection. Furthermore, on a modern system like openSUSE Tumbleweed, autorandr integrates seamlessly with the systemd init system. This means it can leverage udev events (the system’s way of detecting hardware changes like plugging in a monitor) to trigger the profile switching automatically in the background, offering a truly hands-off experience after the initial setup.

Key Benefits Elaborated:

• Automatic Detection & Application: autorandr intelligently identifies connected displays, often using their unique EDID information, and compares this against its library of saved profiles to find the best match, applying it instantly.
• Ease of Use: The “save once, use anywhere” philosophy drastically reduces complexity. Instead of remembering complex xrandr commands or navigating display settings repeatedly, you perform the setup once per unique display combination and save it with a memorable name.
• Flexibility: It excels at managing numerous distinct profiles. You can have profiles for single displays, dual displays in different arrangements (extended desktop, mirrored), displays with specific resolutions or refresh rates, covering virtually any common scenario you encounter.
• Robustness: It gracefully handles situations where display EDID information might be missing, corrupt, or ambiguous – common issues with older projectors or certain adapters. Instead of failing outright or requiring manual intervention like raw xrandr might, autorandr can use other detected properties or fall back to a predefined default profile, ensuring you usually get a usable display state.

#Prerequisites (Raspberry Pi 4B Specific)

Before diving into autorandr installation, optimizing your Raspberry Pi 4B environment is crucial for smooth display operation, especially given its shared memory architecture:

• GPU Memory (gpu_mem): The Raspberry Pi dynamically allocates system RAM between the CPU and the VideoCore GPU. Insufficient memory allocated to the GPU can lead to various graphical issues, such as visual glitches, screen tearing, an inability to drive displays at their native (especially high) resolutions (like 4K), or even completely blank screens. While the default allocation might be sufficient for basic desktop use, connecting multiple monitors or high-resolution displays often requires more. Check your current allocation and consider increasing it if you face issues. You can adjust this by editing the /boot/efi/extraconfig.txt file (the path might vary slightly depending on the exact Tumbleweed Pi image setup) and adding or modifying a line like gpu_mem=256 or gpu_mem=512 (allocating 256MB or 512MB respectively). A reboot is required for this change to be applied by the system.
• Firmware & System Updates: The Raspberry Pi’s firmware and the Linux kernel’s graphics drivers (like V3D DRM) are continually updated to improve hardware compatibility, fix bugs, and enhance performance. These updates often include improved handling of display detection protocols like EDID. Keeping your openSUSE Tumbleweed system fully updated is the best way to ensure you have the latest fixes and broadest compatibility. Use the standard Tumbleweed update command, sudo zypper dup (which performs a full system upgrade). Regularly running this ensures you benefit from the latest improvements relevant to display handling.

#Installation on openSUSE Tumbleweed

You have several avenues to install autorandr on your system:

1. Check Standard Repositories (Try First): OpenSUSE Tumbleweed might already include autorandr in its main repositories. You can check its availability and install it if found:
   # Check if the package exists
   zypper info autorandr
   # If available, install it
   sudo zypper refresh
   sudo zypper install autorandr

2. Recommended Method (openSUSE Build Service - OBS): The autorandr author often maintains a more up-to-date version in a dedicated OBS repository. This is generally the preferred method if the package isn’t in the main repos or if you need the latest features/fixes:
   # Add the repository
   sudo zypper addrepo https://download.opensuse.org/repositories/home:phillipberndt/openSUSE_Tumbleweed/home:phillipberndt.repo
   # Refresh repository metadata
   sudo zypper refresh
   # Install autorandr from the new repo
   sudo zypper install autorandr

3. Alternative Method (pip): You can install autorandr using Python’s package installer, pip. However, be aware that this method might install it only for the current user, might not integrate as seamlessly with system-wide services like systemd/udev, and might require manual handling of non-Python dependencies. It can also lead to conflicts if system packages also provide parts of the dependencies.
   # Ensure pip is installed, then install autorandr
   sudo zypper install python3-pip
   sudo pip install autorandr

4. Alternative Method (From Source): For developers or those needing the absolute latest code, you can clone the autorandr Git repository and install it manually. This typically requires development tools like gcc and make, and you’ll need to manage dependencies yourself. Consult the README file in the repository for specific instructions.
   # Example (dependencies might vary)
   sudo zypper install git make python3-devel
   git clone https://github.com/phillipberndt/autorandr.git
   cd autorandr
   sudo make install

#Basic Configuration: Creating and Managing Profiles

The fundamental workflow for using autorandr revolves around capturing the state of your display setup for each unique configuration you use:

1. Connect: Physically connect your Raspberry Pi to the specific combination of displays (e.g., a single classroom projector, your dual monitors at the office).
2. Configure Manually (Once): Use your preferred method to arrange the displays exactly how you want them for this specific setup. This could be:
   • Desktop Environment Tools: Use the graphical display settings panel provided by your desktop environment (e.g., xfce4-display-settings in Xfce, the ‘Displays’ panel in GNOME Settings). Here you can typically enable/disable monitors, set resolutions, refresh rates, orientation, and define primary displays and relative positions in an extended desktop.
   • Manual xrandr Commands: For more fine-grained control or scripting, use xrandr directly in the terminal. For example: xrandr --output HDMI-1 --mode 1920x1080 --primary --output DisplayPort-1 --mode 2560x1440 --rotate left --right-of HDMI-1.

3. Save Profile: Once the displays are configured correctly, save this entire state as an autorandr profile using a descriptive name. Choosing a consistent naming convention can be helpful, e.g., location-displaytype-resolution or setup_description.
   # Example for a specific lecture hall projector
   autorandr --save lecturehallB-projector-1280x800

   # Example for your office ultrawide setup
   autorandr --save office-ultrawide-3440x1440

   # Example for a standard 1080p monitor used for testing
   autorandr --save lab-monitor-1080p

   It’s a good idea to back up this directory periodically, especially if you have complex or finely-tuned profiles.

4. List Profiles: To review the profiles you have saved:
   autorandr --list

#Applying Configurations

• Manual Application: You can manually trigger autorandr to detect the currently connected displays and apply the best-matching profile from your saved library. This is useful for testing or if automation isn’t set up.
  autorandr --change

  Behind the scenes, autorandr --change performs several steps: it detects all connected displays and their properties (like EDID, which is data that allows a display to communicate its capabilities to the graphics card), compares this information against the data stored in each of your saved profiles, calculates a “match score” for each profile based on how well it fits the current hardware, and then automatically executes the xrandr commands stored within the highest-scoring profile (if the score exceeds a certain threshold). If no profile matches well enough, it might load the designated default profile or leave the configuration unchanged, depending on your setup.

#Automation (Recommended)

For the most convenient experience, configure autorandr to react automatically whenever you connect or disconnect a display:

• Using systemd Service: This is generally the most robust and manageable method on modern Linux systems like openSUSE Tumbleweed. The autorandr.service unit, when enabled, typically integrates with udev to monitor for display-related hardware events (specifically from the Direct Rendering Manager or DRM subsystem). Upon detecting such an event (e.g., an HDMI cable being plugged in), systemd activates the service, which in turn usually runs autorandr --change to apply the appropriate profile.
  # Enable the service to start on boot and start it immediately
  sudo systemctl enable --now autorandr.service
  # You can check its status later with: systemctl status autorandr.service

• Using udev Rules: autorandr packages often include udev rules (e.g., in /lib/udev/rules.d/) that directly trigger autorandr --change when specific kernel events related to display hardware occur. While this works, managing services through systemd often provides better control, logging, and dependency management. If you installed manually or suspect the rules aren’t active, you might need to reload them:
  sudo udevadm control --reload-rules && sudo udevadm trigger

  With either automation method properly configured, plugging in a known projector or monitor should automatically result in your saved configuration being applied, although there might be a brief delay (a few seconds) while autorandr detects the display and applies the profile.

#Setting a Default Fallback Profile

It’s highly recommended to define a “fallback” or “default” profile. This profile will be automatically applied by autorandr --change (and thus by the automated services) if you connect a display configuration that doesn’t closely match any of your specifically saved profiles. The primary purpose is to prevent being left with an unusable or awkward display state (like a very low resolution, incorrect mirroring, or only the laptop’s internal display active when an external one is connected but unrecognized).

1. Choose and Save a Safe Profile: Configure your display(s) to a very common and widely supported resolution, like 1920x1080@60Hz or perhaps 1280x720@60Hz, which most monitors and projectors should handle without issue. Save this configuration:
   # Example: Configure for 1920x1080 manually first, then save
   autorandr --save fallback-1080p

2. Set as Default: Tell autorandr to use this profile as the default:
   autorandr --default fallback-1080p

   Now, when connecting an unknown display, autorandr will attempt to apply this safe configuration, maximizing the chances of getting a usable picture.

#Advanced Usage

autorandr offers features beyond basic profile switching:

• Wildcard EDID Matching: Sometimes you might have several projectors or monitors of the same model series. Their EDIDs might be very similar but differ slightly (e.g., in serial number fields). To create a single profile that matches all of them, you can edit the config file within the profile directory (e.g., ~/.config/autorandr/classroom-projectors/config). Find the line(s) specifying the EDID for the relevant output(s) and replace the differing parts (or less critical parts) with an asterisk (*).
  Example snippet from ~/.config/autorandr/some_profile/config:*
  output HDMI-1
  # edid 00ffffffffffff001e6d[…] # Original specific EDID
  edid 00ffffffffffff001e6d* # Matches any EDID starting with this prefix

  Caution: Be careful not to make the wildcard too broad, or it might incorrectly match unintended displays.

• Hook Scripts: You can automate actions that should occur whenever a specific profile is loaded or unloaded. Create executable scripts (e.g., using bash or python) named preswitch (runs before switching to this profile), postswitch (runs after switching to this profile), predetect (runs before detection), or postdetect (runs after detection) inside a profile’s directory (~/.config/autorandr/<profile_name>/) or the global config directory (~/.config/autorandr/). Common uses for postswitch include:
  • Setting a specific desktop wallpaper: feh --bg-scale /path/to/wallpaper.jpg
  • Restarting desktop panels if they don’t resize correctly: xfce4-panel -r
  • Changing the default audio output sink.
    Remember to make the scripts executable: chmod +x ~/.config/autorandr/<profile_name>/postswitch.
• Forcing Matches (–match-edid): In rare troubleshooting scenarios where display properties other than EDID might be causing incorrect profile matching, you can experiment with options like autorandr --change --match-edid to force matching based primarily or solely on the EDID information. Consult man autorandr for details.

#Troubleshooting

If autorandr doesn’t behave as expected:

• Check Detected Profiles & Scores: See what autorandr currently detects and how well it matches known profiles. The output shows detected profiles and their calculated match scores.
  autorandr --detected

• Use Debug Mode: This provides highly detailed output about the detection process, including EDIDs read, profiles considered, matching scores, and the exact xrandr commands being generated and executed. This is invaluable for diagnosing why a specific profile isn’t being selected.
  autorandr --change --debug

• Check System Logs: Look for errors or warnings related to the graphics driver (DRM) or EDID processing in the system journal. This can reveal underlying hardware or driver issues.
  # View live logs (press Ctrl+C to stop)
  journalctl -f | grep -i -E “drm|edid|autorandr”
  # View logs from the current boot
  journalctl -b | grep -i -E “drm|edid|autorandr”

• Ensure System Updates: Reiterate the importance of sudo zypper dup to ensure you have the latest kernel, graphics drivers, and potentially autorandr fixes.
• Check Physical Connections: Sometimes the simplest solution is overlooked. Ensure HDMI or DisplayPort cables are securely plugged in at both the Raspberry Pi and the display ends. Try a different cable if problems persist.

#Alternative: Hardware HDMI EDID Emulator

For displays that consistently cause problems due to missing, corrupt, or non-standard EDID information, a hardware HDMI EDID Emulator (also known as an EDID ghost or dummy plug) can be a viable workaround. This small device plugs into an HDMI port on the Pi and contains a chip pre-programmed with standard EDID data (e.g., for a 1080p monitor). The Raspberry Pi’s operating system reads the EDID from the emulator instead of the actual connected display. This effectively forces the Pi to “see” a standard display, often resolving issues with problematic hardware like some older projectors or KVM switches. While it provides consistency, it lacks the dynamic flexibility of autorandr – it forces one specific configuration regardless of what display (if any) is actually connected downstream. It’s a targeted solution for specific problematic hardware, not a replacement for general-purpose profile management.

#Resources

• autorandr GitHub Repository: The primary source for code, detailed documentation (README), and reporting issues. Check the Issues page here for existing bug reports or troubleshooting discussions. https://github.com/phillipberndt/autorandr
• openSUSE Build Service Package: Link to the specific package page for the OBS repository, useful for checking versions and build status. https://build.opensuse.org/package/show/home:phillipberndt/autorandr

By carefully configuring autorandr and leveraging its automation features, you can significantly streamline the process of using your Raspberry Pi 4B with diverse display setups, making your transitions between classroom, office, and other locations much smoother and less prone to technical interruptions.

#bash script to collect monitor data on Debian

• Installs all required tools (including optional edid-decode).
• Detects every DRM connector (VGA, HDMI, DP, DVI, etc.), whether EDID-capable or not.
• Enumerates connected and disconnected outputs via xrandr.
• Logs EDID (sysfs, get-edid, DDC/CI), general hardware info (hwinfo, inxi, lshw), and udev data.
• Provides a summary and guidance on extracting modeline parameters.
• Offers an optional CVT-based modeline generator/applicator.

Save as ~/monitor-info.sh, then:

Script:

Next Steps:

1. Open $OUTDIR/summary.txt to see detected connectors and outputs.
2. Inspect edid_sysfs_*.log and edid_getedid.log for Detailed Timing Descriptors (pixel clock, hsync/vsync, porches).
3. Enclose those values within this bash script: ``` #!/bin/bash

#Improved Temporary Xrandr configuration script

#These settings will only apply to the current X session and

#will not persist after a reboot or X server restart.

#Ensure this script is run from within an active X Window System session.

#

#This script now checks the connection status of HDMI-1 and DP-1

#before attempting to configure them, based on live ‘xrandr’ output.

#If DP-1 is the only connected monitor, it attempts to set screen DPI

#based on its physical dimensions.

#Check if xrandr command is available

if ! command -v xrandr &> /dev/null; then echo “Error: xrandr command not found. Please ensure it is installed and in your PATH.” exit 1 fi

#Check if bc command is available (for DPI calculations)

BC_AVAILABLE=false if ! command -v bc &> /dev/null; then echo “Warning: bc command not found. DPI calculation for DP-1 will be skipped.” echo “Please install ‘bc’ if you want to enable automatic DPI setting.” else BC_AVAILABLE=true fi

echo “Applying temporary xrandr settings…” echo “This script will check current display connection statuses.” echo “Verify your display identifiers (e.g., HDMI-1, DP-1) by running ‘xrandr’ in a terminal.”

#Define mode names and modelines

MODE_NAME_1=”1152x864_60.00” # For DP-1 MODELINE_1=”81.75 1152 1216 1336 1520 864 867 871 897 -hsync +vsync” MODE_1_WIDTH_PX=1152 MODE_1_HEIGHT_PX=864

MODE_NAME_2=”2560x1080_60.00” # For HDMI-1 MODELINE_2=”230.00 2560 2720 2992 3424 1080 1083 1093 1120 -hsync +vsync”

#Define output names

OUTPUT_DP=”DP-1” # DisplayPort output OUTPUT_HDMI=”HDMI-1” # HDMI output

#Physical dimensions for DP-1 (in mm)

DP_WIDTH_MM=419 DP_HEIGHT_MM=236

#— Define New Modes (always attempt this) —

echo “” echo “Defining new mode: $MODE_NAME_1” xrandr –newmode “$MODE_NAME_1” $MODELINE_1 if [ $? -ne 0 ]; then echo “Warning: Could not define mode $MODE_NAME_1.” echo “Possible issues: mode already exists (use ‘xrandr’ to check), incorrect modeline parameters, or xrandr limitations.” fi

echo “Defining new mode: $MODE_NAME_2” xrandr –newmode “$MODE_NAME_2” $MODELINE_2 if [ $? -ne 0 ]; then echo “Warning: Could not define mode $MODE_NAME_2.” echo “Possible issues: mode already exists (use ‘xrandr’ to check), incorrect modeline parameters, or xrandr limitations.” fi

#— Check current connection status of displays —

echo “” echo “Checking current display connection status…” IS_DP_CONNECTED=false if xrandr | grep -q “^${OUTPUT_DP} connected”; then IS_DP_CONNECTED=true echo “- $OUTPUT_DP is detected as connected.” else echo “- $OUTPUT_DP is detected as disconnected.” fi

IS_HDMI_CONNECTED=false if xrandr | grep -q “^${OUTPUT_HDMI} connected”; then IS_HDMI_CONNECTED=true echo “- $OUTPUT_HDMI is detected as connected.” else echo “- $OUTPUT_HDMI is detected as disconnected.” fi

#— Initial Positioning Command (if both displays are connected) —

echo “” if $IS_HDMI_CONNECTED && $IS_DP_CONNECTED; then echo “Attempting to set $OUTPUT_HDMI –auto –above $OUTPUT_DP…” xrandr –output “$OUTPUT_HDMI” –auto –above “$OUTPUT_DP” if [ $? -ne 0 ]; then echo “Warning: Could not set $OUTPUT_HDMI –auto –above $OUTPUT_DP.” else echo “Successfully attempted to position $OUTPUT_HDMI above $OUTPUT_DP.” fi elif ! $IS_HDMI_CONNECTED && $IS_DP_CONNECTED; then echo “Skipping initial positioning: $OUTPUT_HDMI is disconnected. $OUTPUT_DP is primary.” elif $IS_HDMI_CONNECTED && ! $IS_DP_CONNECTED; then echo “Skipping initial positioning: $OUTPUT_DP is disconnected. $OUTPUT_HDMI is primary.” else echo “Skipping initial positioning: Both $OUTPUT_HDMI and $OUTPUT_DP appear to be disconnected.” fi

#— Configure DP Output ($OUTPUT_DP) —

echo “” if $IS_DP_CONNECTED; then echo “Configuring $OUTPUT_DP…” echo “Adding mode $MODE_NAME_1 to $OUTPUT_DP” xrandr –addmode “$OUTPUT_DP” “$MODE_NAME_1” if [ $? -ne 0 ]; then echo “Error adding mode $MODE_NAME_1 to $OUTPUT_DP.” echo “Ensure $OUTPUT_DP is truly connected, the mode was defined, and supports this mode.” else echo “Setting $OUTPUT_DP to mode $MODE_NAME_1” xrandr –output “$OUTPUT_DP” –mode “$MODE_NAME_1” if [ $? -ne 0 ]; then echo “Error setting $OUTPUT_DP to mode $MODE_NAME_1.” else # If DP-1 is the only connected monitor, try to set screen DPI if ! $IS_HDMI_CONNECTED && $BC_AVAILABLE; then echo “” echo “DP-1 ($OUTPUT_DP) appears to be the only connected display and ‘bc’ is available.” echo “Calculating DPI for screen based on DP-1 physical dimensions ($DP_WIDTH_MM mm x $DP_HEIGHT_MM mm) and mode $MODE_NAME_1 ($MODE_1_WIDTH_PX x $MODE_1_HEIGHT_PX).”

#— Configure HDMI Output ($OUTPUT_HDMI) —

echo “” if $IS_HDMI_CONNECTED; then echo “Configuring $OUTPUT_HDMI…” echo “Adding mode $MODE_NAME_2 to $OUTPUT_HDMI” xrandr –addmode “$OUTPUT_HDMI” “$MODE_NAME_2” if [ $? -ne 0 ]; then echo “Error adding mode $MODE_NAME_2 to $OUTPUT_HDMI.” echo “Ensure $OUTPUT_HDMI is truly connected, the mode was defined, and supports this mode.” else echo “Setting $OUTPUT_HDMI to mode $MODE_NAME_2” xrandr –output “$OUTPUT_HDMI” –mode “$MODE_NAME_2” if [ $? -ne 0 ]; then echo “Error setting $OUTPUT_HDMI to mode $MODE_NAME_2.” fi fi else echo “Skipping configuration for $OUTPUT_HDMI as it is disconnected.” fi

echo “” echo “Temporary xrandr settings applied (or attempted for connected displays).” echo “Current screen configuration (relevant connected displays):” xrandr | grep “ connected”

echo “” echo “If you encounter issues, please check:” echo “1. Your display output names ($OUTPUT_DP, $OUTPUT_HDMI) are correct (use ‘xrandr’ to verify).” echo “2. Your displays are properly connected and powered on.” echo “3. The modelines are compatible with your hardware.” echo “4. Review any error messages above from xrandr.” echo “5. If DPI was set, verify with ‘xdpyinfo | grep resolution’.”

To use this script:

1. Save it as debian_display_setup_prep.sh.
2. Make it executable: chmod +x debian_display_setup_prep.sh.
3. Run it as root: sudo ./debian_display_setup_prep.sh.
4. Reboot if you made changes to critical system configurations like GPU memory.

#Phase 2: Understanding and Using the Provided Scripts

Your original query included two scripts from a blog post. Here’s how they fit into the setup:

#A. monitor-info.sh (Bash script to collect monitor data)

• Purpose: This script is a diagnostic and information-gathering tool. It is not meant to run automatically every time an X session starts. Its purpose is to help you understand your display hardware, especially when configuring new or problematic monitors. The data it gathers (EDID, timings) is crucial for crafting manual xrandr commands if needed.
• “Enclosing” this script:
  1. The “One-Time System Preparation Script” (Phase 1) already installed all the command-line tools monitor-info.sh uses.
  2. Below is the script content. Save it to a file in your home directory (e.g., ~/monitor-info.sh).
  3. Make it executable: chmod +x ~/monitor-info.sh.
  4. Run it manually with sudo ~/monitor-info.sh when you need to diagnose a display setup before creating an autorandr profile for it.

#B. “Improved Temporary Xrandr configuration script”

• Purpose: This script provides a template of xrandr commands for a specific dual-monitor setup (DP-1 and HDMI-1) including custom modelines and DPI settings.
• “Enclosing” this script:
  1. It is not meant to be run automatically on every X session start if you are using autorandr as the primary display manager. Doing so could conflict with autorandr.
  2. Instead, its xrandr commands and logic should be used as a reference or template when you are manually configuring your displays once before saving an autorandr profile (Phase 3, Step 2).
  3. The DPI setting part is more dynamic and, if desired for a specific autorandr profile, should be placed into an autorandr hook script (see Phase 3, Step 7).
  4. Below is the script content for your reference during manual configuration:

#Phase 3: Configuring autorandr (Manual Steps for Each User and Setup)

autorandr works by saving your current display configuration into a “profile.” This needs to be done by the user (root or normal user) within their own X session for each unique display setup.

Steps to create profiles:

1. Connect Displays: Attach your specific combination of monitors, projectors, etc.
2. Manually Configure Displays: Use your desktop environment’s display settings tool or manual xrandr commands in a terminal to arrange your displays exactly as desired.
   • Refer to the xrandr commands in the “Improved Temporary Xrandr configuration script” above as a template for defining modelines (xrandr --newmode ...), adding modes (xrandr --addmode ...), and setting outputs (xrandr --output <name> --mode <mode> --pos <XxY> --primary --rotate <normal|left|right|inverted> --output <other_name> ...).
   • For example, to set up two monitors, HDMI-1 (2560x1080) to the left of DP-1 (1920x1080, primary):
     # (Assuming modelines for these resolutions are already supported or added via --newmode) xrandr --output HDMI-1 --mode 2560x1080 --pos 0x0 --rotate normal \ --output DP-1 --mode 1920x1080 --pos 2560x0 --rotate normal --primary
3. Save the autorandr Profile: Once displays are perfectly configured, save this state:
   autorandr --save <profile_name>

   Use descriptive names (e.g., office_dual_monitors, lecture_projector_1024x768).

4. Profile Locations and User Context:
   • Profiles are saved in ~/.config/autorandr/ (e.g., /root/.config/autorandr/ for root, /home/youruser/.config/autorandr/ for youruser).
   • For common profiles accessible by both root and normal users (if no user-specific one matches): You can manually copy or create profile directories in /etc/xdg/autorandr/. autorandr checks user-specific paths first. This is useful if root and a normal user often encounter the same display setups.
5. Repeat for Other Setups: Repeat steps 1-3 for every different display configuration.
6. List and Set Default Profile:
   autorandr --list # Review saved profiles # Configure a very safe, common display setup (e.g., single monitor 1920x1080) # Then save it and set it as default: autorandr --save fallback_safe_1080p autorandr --default fallback_safe_1080p

   This default profile is crucial if an unknown display setup is detected.

7. Implementing DPI Settings via Hooks (Optional): If you want the DPI calculation from the “Improved Temporary Xrandr configuration script” to apply when a specific autorandr profile is loaded, create a postswitch hook script within that profile’s directory.

   • For a profile named my_specific_setup (directory: ~/.config/autorandr/my_specific_setup/ or /etc/xdg/autorandr/my_specific_setup/), create an executable script: .../my_specific_setup/postswitch

     #!/bin/sh # # postswitch hook for profile 'my_specific_setup' to set DPI. # IMPORTANT: Customize all variables below (OUTPUT_NAME, MODE_WIDTH_PX, etc.) # to match the specifics of THIS 'my_specific_setup' profile. # # For debugging hooks, you can use logger or write to a temp file: # echo "Running postswitch for my_specific_setup at $(date)" >> /tmp/autorandr_hook_debug.log if ! command -v bc > /dev/null 2>&1; then # echo "postswitch_dpi: bc command not found, skipping DPI." >> /tmp/autorandr_hook_debug.log exit 0 fi # --- START CUSTOMIZATION for 'my_specific_setup' profile --- OUTPUT_NAME="DP-1" # The actual output name (e.g., DP-1, HDMI-A-0) for this profile's main display MODE_WIDTH_PX=1152 # Horizontal resolution of OUTPUT_NAME in this profile MODE_HEIGHT_PX=864 # Vertical resolution of OUTPUT_NAME in this profile PHYS_WIDTH_MM=419 # Physical width in mm of the monitor connected to OUTPUT_NAME PHYS_HEIGHT_MM=236 # Physical height in mm of the monitor connected to OUTPUT_NAME # --- END CUSTOMIZATION --- # Check if the relevant display is configured as expected by autorandr for this profile # This grep is a basic check; more robust checks might be needed for complex setups. if xrandr | grep -q "^${OUTPUT_NAME} connected.*${MODE_WIDTH_PX}x${MODE_HEIGHT_PX}"; then if [ "$PHYS_WIDTH_MM" -gt 0 ] && [ "$PHYS_HEIGHT_MM" -gt 0 ]; then DPI_H_CALC=$(bc -l <<< "scale=2; $MODE_WIDTH_PX / ($PHYS_WIDTH_MM / 25.4)") DPI_V_CALC=$(bc -l <<< "scale=2; $MODE_HEIGHT_PX / ($PHYS_HEIGHT_MM / 25.4)") if [[ -n "$DPI_H_CALC" && -n "$DPI_V_CALC" && "$DPI_H_CALC" =~ ^[0-9]+([.][0-9]+)?$ && "$DPI_V_CALC" =~ ^[0-9]+([.][0-9]+)?$ ]]; then AVG_DPI=$(printf "%.0f" "$(bc -l <<< "($DPI_H_CALC + $DPI_V_CALC) / 2")") # echo "postswitch_dpi: Setting screen DPI to $AVG_DPI for $OUTPUT_NAME." >> /tmp/autorandr_hook_debug.log xrandr --dpi "$AVG_DPI" # else # echo "postswitch_dpi: DPI calculation failed." >> /tmp/autorandr_hook_debug.log fi # else # echo "postswitch_dpi: Physical dimensions for $OUTPUT_NAME are zero." >> /tmp/autorandr_hook_debug.log fi # else # echo "postswitch_dpi: Expected display $OUTPUT_NAME not found or not in expected mode." >> /tmp/autorandr_hook_debug.log fi exit 0

   • Make the hook script executable: chmod +x .../my_specific_setup/postswitch. Repeat for other profiles if needed, customizing variables each time.

#Phase 4: Automating autorandr

This ensures autorandr acts on display changes and at X session startup.

1. Systemd Service (for hotplugging and system events): The autorandr.service (enabled in Phase 1) handles display changes detected by udev (e.g., plugging/unplugging monitors). This works system-wide, even outside or during an X session. It’s the primary mechanism for dynamic changes.

2. X Session Startup Script (for startx): To explicitly trigger autorandr when an X session is initiated via startx (by root or any normal user), create: File: /etc/X11/Xsession.d/50-autorandr-load-profile

   #!/bin/sh # # /etc/X11/Xsession.d/50-autorandr-load-profile # Load autorandr profile on X session start (for startx users). # This script runs as the user starting the X session. # if command -v xrandr >/dev/null 2>&1 && command -v autorandr >/dev/null 2>&1; then # --change: detects displays, loads best profile. # --batch: implies --force, suppresses xrandr output unless error. Good for scripts. autorandr --change --batch # For debugging, you could log: # LOG_DIR="/tmp/autorandr_logs" # mkdir -p "$LOG_DIR" # echo "Xsession autorandr trigger for $(whoami) at $(date)" >> "$LOG_DIR/xsession_trigger.log" # autorandr --change --debug >> "$LOG_DIR/autorandr_xsession_$(whoami)_$(date +%Y%m%d-%H%M%S).log" 2>&1 fi exit 0
   • Activate: Save and make executable: sudo chmod +x /etc/X11/Xsession.d/50-autorandr-load-profile.
   • Interplay: The autorandr.service provides continuous monitoring. This Xsession script ensures that when startx is explicitly run, autorandr evaluates the display situation at that specific moment, respecting the current user’s profiles.

#Phase 5: Advanced autorandr Features and Troubleshooting

• Advanced Features (from blog post):
  • Wildcard EDID Matching: Edit config file in profile dirs (e.g., ~/.config/autorandr/<profile>/config) to use * in EDID strings for flexibility with similar monitors.
  • Other Hook Scripts: preswitch, predetect, postdetect for more automation (e.g., restarting panels, changing audio sinks). Remember chmod +x for all hook scripts.
• Troubleshooting (from blog post):
  • autorandr --detected: See current detection and scores.
  • autorandr --change --debug: Verbose output for manual diagnosis in an X session.
  • journalctl -f | grep -i -E "drm|edid|autorandr": Live system logs.
  • journalctl -b | grep -i -E "drm|edid|autorandr": Logs from current boot.
  • Ensure system is updated: sudo apt update && sudo apt full-upgrade -y.
  • Check physical cable connections.

By following these phases, you’ll have a robust system where autorandr manages your display configurations automatically when displays are connected/disconnected or when you start an X session with startx, leveraging the specific configurations and logic from the provided scripts. Remember to adapt profile names and hook script details to your exact hardware and preferences.