Being a multi-discipline engineer can be challenging at times. Perhaps most challenging when it comes to running all of the preferred environments for mechanical CAD, electrical CAD, and firmware development. I like to run bare metal Windows on my desktops so I can run SolidWorks with good performance but I have also standardized on using Ubuntu for EE and firmware development. To do this, I use a VM with VMware workstation player to avoid having multiple computers.

One of the most annoying issues came up when I initially set up this environment. The issue was that the scrolling behavior stopped any time the mouse cursor was moving. This might not seem like much, but it is extremely difficult to interact with the VM proficiently with this issue. Although a few others had shared their frustrations on various forums, there were no solutions provided. After spending a few hours breaking down the issue, I came up with a solution which I will explain in detail and provide step-by-step instructions to reproduce.

My setup:

• Windows 10 Pro running bare metal
• VMware Workstation 17 Player
• Ubuntu 22.04 LTS running in VMware Workstation

Step-by-step fixes:

1. Install evdev with:  

sudo apt-get install xserver-xorg-input-evdev-dev

2. Next, update xorg config to use evdev for the pointer:

cd /usr/share/X11/xorg.conf.d/
sudo vim 40-libinput.conf

Change the following:

Section "InputClass"
        Identifier "libinput pointer catchall"
        MatchIsPointer "on"
        MatchDevicePath "/dev/input/event*"
        Driver "libinput"
EndSection

To:

Section "InputClass"
        Identifier "libinput pointer catchall"
        MatchIsPointer "on"
        MatchDevicePath "/dev/input/event*"
        Driver "evdev"
EndSection

3. Install imwheel with:

sudo apt install imwheel

4. Start imwheel with the following command to only intercept scroll wheel:

imwheel -b "4 5"

5. Now, test it out! The scrolling issue should be resolved in any window with a scroll bar.

6. The final step is to add the command to start imwheel so it will be called conveniently when the system starts. If you want to have it start automatically on boot, you could make a systemd service to call the following in a small script. For my purposes, I just included the following in the .bashrc file so it would run upon launching a terminal:

# Start imwheel for scrolling fix and silence output:
imwheel -b "4 5" > /dev/null 2>&1

That's it, no more super annoying scroll-blocking behavior!

Intro

One of the most important components of a robust infrastructure is an automated backup solution. Typically this consists of both onsite and offsite backup solutions, both of which are separate host machines from the one or ones that are being backed up. One of the things I like most about Proxmox is the companion backup solution called Proxmox Backup Server or PBS. This works great and allows automatic backups but at the cost of another server running and sipping power. In a production environment, the power draw and associated costs for one additional sever are negligible. However in my home lab, and others like it, an additional 200W of power draw 24/7 works out to almost $50/month which is a lot for an appliance that is only utilized a few times a week. With this in mind, I started down the path of configuring my backup solution to be warm storage for power and cost savings.

What are Storage Temperatures?

Storage temperatures (hot and cold) are used to describe the latency to access data on a storage device. Hot means the data can be accessed immediately and frequently like an SSD with a high bandwidth link. Cold means the data can only be accessed slowly and infrequently like an external HDD of old archival storage. Often cold also means the storage is durable, not networked, and located offsite for security purposes. For my onsite backup application, I want an in-between solution or warm storage. I know the exact times each week that I need the storage to be accessible for backup jobs and I also don't mind having several minutes of latency to access the data. The goal with warm storage is to keep the backup server powered off until a backup job is scheduled or the data needs to be manually accessed.

Implementation

Overview

Great, so how do we implement a solution to automatically power on/off the server based on backup jobs? Well, there are many ways to skin this cat but I chose to start with the simplest solution. Let's break down what I want to have happen:

1. The backup server is powered on a few minutes before a backup job starts.
2. The backup job starts and takes some time to complete.
3. The backup job completes and the backup server is gracefully shut down.
4. This behavior repeats for every scheduled backup job automatically.

Let's go over how to implement each one of these behaviors.

To power on the server, I will be using IPMI Tool to send a power-on command. This is most reliable for my setup and my Dell PowerEdge server supports it. Alternatively, you can use wake-on-lan (WOL) if your server does not have an IPMI interface.

Once the server is powered on, for simplicity, I was planning to wait a predetermined amount of time which slightly exceeds the time it takes for the backup job to complete. However, it turns out that the backup time is highly variable depending on how much of the image has changed (dirty) since the last backup job. Due to this, I found a way to detect when the backup job is completed by watching journalctl logs for the backup completion log message.

To shut down the server, IPMI can not be used (even the soft shutdown) since this does not result in a truly graceful shutdown. This is atleast true with my server model (Dell PE R730XD) and OS (Proxmox PBS). Instead, I use SSH and run a shutdown command to initiate a graceful shutdown from within PBS.

Scheduling and executing these commands are performed with a systemd service and timer which calls a bash script. I matched the time and days of the week I scheduled backup jobs in Proxmox with the systemd timer plus a few minutes of buffer for the backup server to boot.

Technical Details

Two dependancies (ipmitool and sshpass) are required for the bash script to wake and shutdown the backup server and can be installed with the following commands:

apt install ipmitool
apt install sshpass

Below is the simple bash script (/root/backup_power.sh) I made to power on the server, wait for the backup job to complete, and then gracefully power down the server. This script is on my main Proxmox server that schedules the backup jobs and also runs 24/7.

#!/bin/bash

# backup_power.sh
# A script called by systemd to wake pbs server
# over ipmi before backup job starts and shutdown
# after backup job completes

# Power on server once called by systemd timer:
echo "Powering on PBS"
ipmitool -I lanplus -H <server-ip> -U <user> -P <pass> chassis power on

# Set variables equal to number of backup completions today so far
backup_finished_count_initial=$(journalctl --since today | grep "Backup job finished" | wc -l)
backup_finished_count=$(journalctl --since today | grep "Backup job finished" | wc -l)

echo "Waiting for backup job completion"

# Wait for backup to complete and check every second
while [ $backup_finished_count -eq $backup_finished_count_initial ]; do
  backup_finished_count=$(journalctl --since today | grep "Backup job finished" | wc -l)
  sleep 1s
done

echo "Detected backup job completion, powering off PBS in 1 minute"
sleep 1m  # Wait one minute before graceful shutdown

# Gracefully power off server after backup job is complete
echo "Gracefully powering off PBS"
sshpass -p "<pass>" ssh -o StrictHostKeyChecking=no root@<server-ip> shutdown

Fill in your server-ip, ipmi user and pass, and ssh user and pass and don't forget to make the script executable with:

 chmod +x backup_power.sh 

Below is the systemd service (/etc/systemd/system/backup_power.service) which executes the above bash script.

[Unit]
Description=Service to power on and off PBS server for backup jobs
Wants=backup_power.timer

[Service]
Type=oneshot
ExecStart=/root/backup_power.sh

[Install]
WantedBy=multi-user.target

The service is enabled with the following.

systemctl enable backup_power.service

Below is the systemd timer (/etc/systemd/system/backup_power.timer) which fires the above service on my backup days (Monday and Friday) 5 minutes before the backup job begins (5:55 AM).

[Unit]
Description=Calls backup_power service on backup days 5 minutes before backup job starts.
Requires=backup_power.service

[Timer]
Unit=osmium_backup_power.service
OnCalendar=Mon,Fri *-*-* 5:55:00
AccuracySec=10s

[Install]
WantedBy=timers.target

You'll want to enable and start the timer with the following after creation:

systemctl enable timer backup_power.timer
systemctl start timer backup_power.timer

This will also start the service and run your script for the first time. Make sure it is functioning as expected. Check the status of the service and timer with the following.

systemctl status backup_power.service
systemctl status backup_power.timer

Check the logs for more detailed debugging with

journalctl

or search for specifics in the logs with

journalclt | grep <string-to-search>

Hopefully your timer and service run without issue and you now have automatic power on and power off of your now warm storage backup server.

Final Thoughts

This solution has worked well for my needs and was very simple to get running. One improvement I would like to add is scheduled ZFS pool scrubbing once a month or so to make sure the disks are healthy. Also, adding a 10GBE fiber link between the servers would make the backup jobs on the order of a few minutes. Well, that's it for this project, I hope this was useful for some people setting up their backup solution. Hopefully, this saves you some power and money as it has for me.

Intro

I recently decided to pick up a broken iRobot Roomba S9 on eBay to repair and experiment with (look for my Roomba S9 "Error 31" repair tutorial in the future). Once I got mine working, the first thing I wanted to do was fully integrate it into my Home Assistant environment. For the basics this was straightforward, with the iRobot integration, but it was non-trivial and took some experimenting to get the other features I wanted like being able to execute individual room/zone cleaning or queue up multiple rooms/zones. Since I could not find anyone else who had done something like this, I decided to document the process here for others looking to do the same or similar.

In this tutorial, we'll go over:

1. Installing and configuring the iRobot integration in Home Assistant.
2. Creating a simple Lovelace card for the Roomba.
3. Intercepting and sending custom commands to the Roomba.
4. Creating a Python script to send multiple regions to be cleaned by the Roomba in the order selected.

Install and Configure the iRobot Integration

First, we are going to start by installing the iRobot integration in Home Assistant. I was unable to get the automatic configuration to work and had to manually fetch the credentials for my robot. I'll go over those manual steps in detail.

Install Integration

To begin, install the integration below:

iRobot Roomba and Braava

Instructions on how to integrate your Wi-Fi enabled Roomba and Braava within Home Assistant.

Home AssistantHome Assistant

Once installed, the configuration should start. Try the automatic configuration but it did not work for me. If that is the case with your instance too, see the next steps to complete manually.

Install Dorita980 On Linux

On a Linux terminal (I am using Ubuntu) install Dorita980 via NPN.

GitHub - koalazak/dorita980: Unofficial iRobot Roomba and Braava (i7/i7+, 980, 960, 900, e5, 690, 675, m6, etc) node.js library (SDK) to control your robot

Unofficial iRobot Roomba and Braava (i7/i7+, 980, 960, 900, e5, 690, 675, m6, etc) node.js library (SDK) to control your robot - GitHub - koalazak/dorita980: Unofficial iRobot Roomba and Braava (i7...

GitHubkoalazak

This is an unofficial OpenSource SDK for iRobot Roomba and Braava platforms which allows for direct LAN control of the robots. All the things I love to see! It can be installed with the following command:

sudo npm install -g dorita980

Get the Credentials for Manual Setup

To get the required credentials for the integration's manual setup (BLID & Password), run the following command with your iRobot account credentials used on the iRobot app:

get-roomba-password-cloud <iRobot_email> "<iRobot_pass>"

You should see the following output with your Roomba(s) information:

Found 1 robot(s)!
Robot "Vladimir" (sku: s955020 SoftwareVer: soho+3.20.7+soho-release-rt421+11):
BLID=> xxxxxxxxxxxxx
Password=> :1:1486937829:gktkDoYpWaDxCfGh <= Yes, all this string.

Use this credentials in dorita980 lib :)

Add your Robot to the Integration

Using the credentials from the previous step, enter them into the integration's configuration manual input. Before clicking submit, you need to put your robot into "connection" mode. To do so, on the S9 platform, hold both the Home and the Spot Clean buttons at the same time until it makes a chime sound and the light ring turns blue (about 2 seconds).

Click submit on your credentials for the iRobot integration in Home Assistant and give it a few seconds to connect. It should connect and add the Roomba as a new device to your Home Assistant.

Create a Basic Vacuum Card

Unfortunately, there is no compatible default Lovelace card for the Roomba device. A simple and fast solution is to add the "more info card" to Home Assistant and use that to display the more info controls for the Roomba. Add the following custom card to your Home Assistant.

GitHub - thomasloven/lovelace-more-info-card: ? Display the more-info dialog of any entity as a lovelace card

? Display the more-info dialog of any entity as a lovelace card - GitHub - thomasloven/lovelace-more-info-card: ? Display the more-info dialog of any entity as a lovelace card

GitHubthomasloven

Make a new card on your Lovelace dashboard with your Roomba device and you should have a card as shown below.

Test out the basic functionality (Play, Pause, Stop, Locate, and Return Home) to verify your integration is working correctly before moving on.

Add Controls For Specific Room & Zone Cleaning

In this section, we will add controls to Home Assistant for telling the Roomba to clean specific rooms/zones. Before starting this section, make sure your Roomba has done at least one mapping run and you have defined the rooms/zones for your map.

From what I can tell, the Roomba stores the map locally on the onboard computer. Each room is given a unique numeric ID under the type "rid" and each zone is given a unique numeric ID under the type "zid".  These IDs are not exposed on the Roomba app so we'll have to "intercept" them using the Dorita980 SDK.

The easiest way I found to get this information is to spin up a docker container with dorita980, fetch the latest command information that was sent to the Roomba, and print that information before exiting. The order of operation is important here, and both the Home Assistant integration and the iRobot app must not be connected to the Roomba for the information to be acquired.

Perform the following steps in this order to acquire a room or zone ID:

1. Navigate to the integration in Home Assistant -> Configure and uncheck Continuous. This will stop the integration from connecting to the Roomba.
2. Open the iRobot app on your phone, send the Roomba to clean a specific room or zone then close the app so it disconnects from the Roomba.
3. Run the following command in your Linux terminal (note you must have docker installed before running):

sudo docker run -e BLID='<BLID>' -e PASSWORD='<PW>' -e ROBOT_IP='<IP>' -it -w /root node sh -c "npm install --silent --no-progress dorita980 && node -e \"var dorita980 = require('dorita980'); var robot = new dorita980.Local(process.env.BLID, process.env.PASSWORD, process.env.ROBOT_IP); robot.getRobotState(['lastCommand']).then((st)=> { console.log(st.lastCommand); process.exit(0); });\""

The output for a single room command:

{
  command: 'start',
  initiator: 'rmtApp',
  time: 1234567890,
  ordered: 1,
  pmap_id: 'F-WxTMqjAUNS33miqwswg',
  regions: [ { region_id: '12', type: 'rid' } ],
  user_pmapv_id: '143158F08305'
}

The output for a double room command:

{
  command: 'start',
  initiator: 'rmtApp',
  time: 1641184321,
  ordered: 1,
  pmap_id: 'C-5UxHWxTMqjAUNS33miqw',
  regions: [ { region_id: '1', type: 'rid' }, { region_id: '10', type: 'rid' } ],
  user_pmapv_id: '220102T080204'
}

As you can see, there are a few pieces of information sent to the Roomba to initiate a room/zone cleaning. The critical pieces here are ordered, pmap_id, and regions. However, only the region fields will change for each room/zone.

Repeat this process for each room/zone matching the name to the ID and type. You can also select all rooms/zones in the iRobot app and note the order. They will appear in the regions list in that order.

Adding a Clean Room Button to Lovelace

Now that we know the command being sent to the Roomba to clean specific rooms/zones, we can make buttons for it in Lovelace. Use the template below to create a button:

type: button
tap_action:
  action: call-service
  service: vacuum.send_command
  service_data:
    entity_id: vacuum.<roomba_name>
    command: start
    params:
      pmap_id: <pmap_id>
      regions:
        - region_id: '<region_id>'
          type: <zid or rid>
name: Clean <room_name>
icon: <icon>

You can repeat this to make a button for each room/zone you have. However, this does not allow for queuing of rooms/zones like in the official app and makes it a bit of a pain to use. Boo!

Room/Zone Queuing With Python

To get around this, we need to format multiple regions together like we saw in the double room command. The best solution for this is to use Python in Home Assistant to read some booleans (and their timestamps) and then format and send the command with required and sorted regions to the Roomba.

HomeAssistant Python Scripts

See the following documentation on quickly getting Python Scripts setup in Home Assistant. I highly recommend following their example and getting your logger setup to show info-level events before continuing.

Here's the TL;DR; of what you need for the Python Scripts and Logger configuration:

# Python Scripts Enable:
python_script:
# Logger:
logger:
  default: info

And more info and examples here:

Python Scripts

Instructions on how to setup Python scripts within Home Assistant.

Home AssistantHome Assistant

Setup Booleans and Buttons for Your Rooms/Zones

Setup a Boolean for each room/zone and corresponding buttons to toggle them. Think of these buttons as checkboxes, this is how the room/zones will be selected and queued before sending to the Roomba.

# Booleans:
input_boolean:
  # Roomba Room Booleans:
  clean_bedroom
  clean_livingroom

type: grid
cards:
  - type: button
    tap_action:
      action: toggle
    name: Clean Bedroom
    icon: mdi:bed-outline
    entity: input_boolean.clean_bedroom
    show_state: true
  - type: button
    tap_action:
      action: toggle
    name: Clean Livingroom
    icon: mdi:sofa-outline
    entity: input_boolean.clean_livingroom
    show_state: true

Next, we need to create a Python script to:

1. Read the states of the Booleans for each room/zone.
2. Sort them in order of selection based on their last_updated field (timestamp).
3. Pack regions into a list and format with the rest of the command structure.
4. Send the command to the Roomba.
5. Set Booleans back to off (false).

############################
#   name: clean_rooms.py   #
#   author: Joshua Hess    #
############################

# Dict of region ID's and RID's
regions = {
    'kitchen': {'region_id': '1', 'type': 'rid'},
    'bathroom': {'region_id': '12', 'type': 'rid'},
    'bedroom': {'region_id': '13', 'type': 'rid'},
    'livingroom': {'region_id': '14', 'type': 'rid'},
    'hallway': {'region_id': '2', 'type': 'rid'},
    'lab': {'region_id': '15', 'type': 'rid'},
    'entryway': {'region_id': '10', 'type': 'rid'},
    'eating_area': {'region_id': '1', 'type': 'zid'},
    'prep_area': {'region_id': '0', 'type': 'zid'}
}

# Lists for Selections and Region Data
selection_list = []
regions_list = []

# Add Boolean State Objects to Selection List if True
if hass.states.get('input_boolean.clean_kitchen').state == 'on':
    selection_list.append(hass.states.get('input_boolean.clean_kitchen'))
if hass.states.get('input_boolean.clean_bathroom').state == 'on':
    selection_list.append(hass.states.get('input_boolean.clean_bathroom'))
if hass.states.get('input_boolean.clean_bedroom').state == 'on':
    selection_list.append(hass.states.get('input_boolean.clean_bedroom'))
if hass.states.get('input_boolean.clean_livingroom').state == 'on':
    selection_list.append(hass.states.get('input_boolean.clean_livingroom'))
if hass.states.get('input_boolean.clean_hallway').state == 'on':
    selection_list.append(hass.states.get('input_boolean.clean_hallway'))
if hass.states.get('input_boolean.clean_lab').state == 'on':
    selection_list.append(hass.states.get('input_boolean.clean_lab'))
if hass.states.get('input_boolean.clean_entryway').state == 'on':
    selection_list.append(hass.states.get('input_boolean.clean_entryway'))
if hass.states.get('input_boolean.clean_eating_area').state == 'on':
    selection_list.append(hass.states.get('input_boolean.clean_eating_area'))
if hass.states.get('input_boolean.clean_prep_area').state == 'on':
    selection_list.append(hass.states.get('input_boolean.clean_prep_area'))

# Sort Selections by Timestamp (In Order of Selection)
selection_list.sort(key=lambda x:x.last_updated)

# Pack Region Data into Region List in Sorted Order
for selection in selection_list:
    # Hard coded check for boolean states and append regsion list
    if selection == hass.states.get('input_boolean.clean_kitchen'):
        regions_list.append(regions['kitchen'])
    if selection == hass.states.get('input_boolean.clean_bathroom'):
        regions_list.append(regions['bathroom'])
    if selection == hass.states.get('input_boolean.clean_bedroom'):
        regions_list.append(regions['bedroom'])
    if selection == hass.states.get('input_boolean.clean_livingroom'):
        regions_list.append(regions['livingroom'])
    if selection == hass.states.get('input_boolean.clean_hallway'):
        regions_list.append(regions['hallway'])
    if selection == hass.states.get('input_boolean.clean_lab'):
        regions_list.append(regions['lab'])
    if selection == hass.states.get('input_boolean.clean_entryway'):
        regions_list.append(regions['entryway'])
    if selection == hass.states.get('input_boolean.clean_eating_area'):
        regions_list.append(regions['eating_area'])
    if selection == hass.states.get('input_boolean.clean_prep_area'):
        regions_list.append(regions['prep_area'])

# Clear all boolean states to false
hass.states.set('input_boolean.clean_kitchen', 'off', '')
hass.states.set('input_boolean.clean_bathroom', 'off', '')
hass.states.set('input_boolean.clean_bedroom', 'off', '')
hass.states.set('input_boolean.clean_livingroom', 'off', '')
hass.states.set('input_boolean.clean_hallway', 'off', '')
hass.states.set('input_boolean.clean_lab', 'off', '')
hass.states.set('input_boolean.clean_entryway', 'off', '')
hass.states.set('input_boolean.clean_eating_area', 'off', '')
hass.states.set('input_boolean.clean_prep_area', 'off', '')

# Pack Data to Send
service_data = {
    'entity_id': 'vacuum.vladimir',
    'command': 'start',
    'params': {
        'pmap_id': '<pmap_id>',
        'regions': regions_list,
        'ordered': 1,
    }
}

# Send Data to Roomba
hass.services.call('vacuum', 'send_command', service_data, False)

Replace your regions, Booleans, and other command data in the above script and test. If it is working correctly, you should be able to set each of your room or zone booleans to queue the rooms/zones to be cleaned. Then, execute the Python script and the Roomba should clean the selected rooms/zones in the order that they were selected. Pretty neat!

The final step is to add a button to your Lovelace that executes the Python script. Follow the template below:

type: button
tap_action:
  action: call-service
  service: python_script.clean_rooms
  service_data: {}
  target: {}
icon_height: 30px
icon: mdi:check
name: Clean Selected Zones

Put that all together and you should have something that looks like this:

Final Thoughts

I am pleased with how this solution has been working for me. I have used this for a few weeks now without any issue. The Python script could be simplified a bit with some thought and for loops but I did not bother since I will not need to add or remove zones frequently if ever.  It would also be a good idea to consider using the secrets.yaml to store some of the Roomba credentials used in the script for good form.

A similar Python script could be used for automation. For example, if you wanted to clean specific rooms in a specific order when certain people leave the house. You can also use the methods described here to add any Roomba functionality into Home Assistant. For example, if you wanted a mapping run button, simply repeat the steps to "intercept" the command, then follow the same basic button template to add a button to Lovelace.

I hope this was useful and saves some time for those looking to integrate this functionality of their Roomba into their Home Assistant.

You just got your new shiny Dell PowerEdge server all set up, but you are getting annoyed by the constant fan ramping up and down or the louder than desired whining of fans. Or worse yet, you just added an "unsupported" GPU or another PCIe device to your PowerEdge and now the fans are ripping at near 100% and screaming away like a jet engine. Fear not! This quick tutorial will get your server to STFU in no time!

When I first got into servers and HomeLab years ago, the standard and accepted way to quiet down PowerEdge servers was to add a resistor in series with each of the fans. Luckily, the newer generations of PowerEdge servers since then have a standard IPMI interface and some known commands to manually control the fan speed. No resistors or soldering irons required this time, nice.

Step By Step

Before We Begin

Before starting, you'll need to:

1. Have access to a Linux machine (Ubuntu recommended)
2. Know your Dell iDRAC IP address and login credentials
3. Make sure IPMI Over LAN option is enabled in iDRAC as shown below

Install IPMI Tool

The first thing to do is install IPMI Tool. To do so, open a terminal and run the following command:

sudo apt install ipmitool

This is what we will use to send raw IPMI commands to the server.

Enter Manual Fan Control Mode

To put the fan speed controller into manual or fixed speed mode, run the following command with your own iDRAC IP and credentials:

ipmitool -I lanplus -H <ip> -U <user> -P <pass> raw 0x30 0x30 0x01 0x00

Set Static Fan Speed

To set a static fan speed run the following command with your own iDRAC IP, credentials, and fan speed as a percentage (0-100) in hexadecimal format (0x00-0x64).

ipmitool -I lanplus -H <ip> -U <user> -P <pass> raw 0x30 0x30 0x02 0xFF <speed>

For example, setting the speed to 10% (0xA) would be as follows:

ipmitool -I lanplus -H <ip> -U <user> -P <pass> raw 0x30 0x30 0x02 0xFF 0xA

NOTE: The static fan speed commands only work if the speed controller is set in manual mode as set above. It will return to automatic mode upon an iDRAC reset.

Maximizing Sound Reduction

It may be counterintuitive, but to minimize sound level, lower fan speed isn't always better. In my case, with the R730 server, I found that the optimum fan speed for minimum perceived sound was 11% fan speed. I found that the lower speeds had a lower frequency sound which was actually more noticeable than the higher frequency whine at slightly higher speeds. It's worth sweeping through the speeds on your setup and finding the highest speed with an acceptable sound level.

Double Check Your Temps

The downside to setting the fans to a static speed is, of course, reduced cooling performance and no reaction during high load. In my case, this was not an issue since my server never goes near full load and my ambient temperatures are consistently quite low. However, it is worth double-checking your temperatures and running some synthetic loads to see what the worse case would look like. You can find most of the critical temperatures exposed in the iDRAC web interface.

Final Thoughts

This method worked great for me and I have used this on all my servers in my home lab. I took this one step further and made a bash script that I can call at a moment's notice if the settings get reset. This can happen if the iDRAC is reset in any way (FW update, SW reset, sustained power outage). You can see the simple bash script below for reference:

#!/bin/bash
ipmitool -I lanplus -H <ip> -U <user> -P <pass> raw 0x30 0x30  0x01 0x00
ipmitool -I lanplus -H <ip> -U <user> -P <pass> raw 0x30 0x30 0x02 0xFF 0xB
echo Server STFU done!

That's it! I hope this was helpful and saves some headaches and bleeding ears for fellow PowerEdge owners.