Initial commit: Battery Life Optimization toolkit with TLP and PowerTOP

- Complete installation and uninstallation scripts
- Optimized TLP configuration for maximum battery life
- PowerTOP analysis and auto-tune functionality
- Real-time battery monitoring with detailed stats
- ThinkPad-specific optimizations and battery thresholds
- Comprehensive documentation and usage guides
- Tested on ThinkPad T14 Gen 1 with 13% power reduction
This commit is contained in:
root
2025-09-29 12:58:11 +02:00
commit ff38460eeb
11 changed files with 2296 additions and 0 deletions

227
scripts/battery-monitor.sh Executable file
View File

@@ -0,0 +1,227 @@
#!/bin/bash
# Battery Status Monitor
# Displays detailed battery information and power consumption
set -euo pipefail
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color
# Function to print header
print_header() {
echo -e "${BLUE}=================================================${NC}"
echo -e "${BLUE} Battery Status Monitor${NC}"
echo -e "${BLUE}=================================================${NC}"
echo
}
# Function to get battery information
get_battery_info() {
local bat_path="/sys/class/power_supply"
local ac_path="/sys/class/power_supply/A[CD]*"
echo -e "${CYAN}Battery Information:${NC}"
echo "----------------------------------------"
# Find all batteries
for battery in "$bat_path"/BAT*; do
if [[ -d "$battery" ]]; then
local bat_name=$(basename "$battery")
local capacity=$(cat "$battery/capacity" 2>/dev/null || echo "N/A")
local status=$(cat "$battery/status" 2>/dev/null || echo "N/A")
local voltage=$(cat "$battery/voltage_now" 2>/dev/null || echo "0")
local current=$(cat "$battery/current_now" 2>/dev/null || echo "0")
local energy_full=$(cat "$battery/energy_full" 2>/dev/null || echo "0")
local energy_now=$(cat "$battery/energy_now" 2>/dev/null || echo "0")
local power_now=$(cat "$battery/power_now" 2>/dev/null || echo "0")
# Convert values to human readable format
voltage_v=$(echo "scale=2; $voltage / 1000000" | bc -l 2>/dev/null || echo "0")
current_a=$(echo "scale=2; $current / 1000000" | bc -l 2>/dev/null || echo "0")
energy_full_wh=$(echo "scale=2; $energy_full / 1000000" | bc -l 2>/dev/null || echo "0")
energy_now_wh=$(echo "scale=2; $energy_now / 1000000" | bc -l 2>/dev/null || echo "0")
power_w=$(echo "scale=2; $power_now / 1000000" | bc -l 2>/dev/null || echo "0")
# Color code based on battery level
if (( $(echo "$capacity >= 80" | bc -l) )); then
color=$GREEN
elif (( $(echo "$capacity >= 50" | bc -l) )); then
color=$YELLOW
else
color=$RED
fi
echo -e "${BLUE}$bat_name:${NC}"
echo -e " Capacity: ${color}${capacity}%${NC}"
echo -e " Status: $status"
echo -e " Voltage: ${voltage_v}V"
echo -e " Current: ${current_a}A"
echo -e " Power: ${power_w}W"
echo -e " Energy: ${energy_now_wh}Wh / ${energy_full_wh}Wh"
# Calculate remaining time
if [[ "$status" == "Discharging" ]] && (( $(echo "$power_w > 0" | bc -l) )); then
remaining_hours=$(echo "scale=2; $energy_now_wh / $power_w" | bc -l)
remaining_minutes=$(echo "scale=0; $remaining_hours * 60" | bc -l)
hours=$(echo "scale=0; $remaining_minutes / 60" | bc -l)
minutes=$(echo "scale=0; $remaining_minutes % 60" | bc -l)
echo -e " Time left: ${hours}h ${minutes}m"
elif [[ "$status" == "Charging" ]] && (( $(echo "$power_w > 0" | bc -l) )); then
charge_needed=$(echo "scale=2; $energy_full_wh - $energy_now_wh" | bc -l)
charge_time=$(echo "scale=2; $charge_needed / $power_w" | bc -l)
charge_minutes=$(echo "scale=0; $charge_time * 60" | bc -l)
charge_hours=$(echo "scale=0; $charge_minutes / 60" | bc -l)
charge_mins=$(echo "scale=0; $charge_minutes % 60" | bc -l)
echo -e " Time to full: ${charge_hours}h ${charge_mins}m"
fi
echo
fi
done
# Check AC adapter status
for ac in $ac_path; do
if [[ -d "$ac" ]] 2>/dev/null; then
local ac_name=$(basename "$ac")
local ac_online=$(cat "$ac/online" 2>/dev/null || echo "0")
if [[ "$ac_online" == "1" ]]; then
echo -e "AC Adapter: ${GREEN}Connected${NC}"
else
echo -e "AC Adapter: ${RED}Disconnected${NC}"
fi
break
fi
done
echo
}
# Function to show TLP status
show_tlp_status() {
if command -v tlp-stat &> /dev/null; then
echo -e "${CYAN}TLP Status:${NC}"
echo "----------------------------------------"
tlp-stat -s 2>/dev/null | head -10
echo
fi
}
# Function to show power consumption
show_power_consumption() {
echo -e "${CYAN}Power Consumption:${NC}"
echo "----------------------------------------"
# Try to get power consumption from various sources
local power_consumption=""
# Method 1: From battery power_now
for battery in /sys/class/power_supply/BAT*; do
if [[ -d "$battery" ]]; then
local power_now=$(cat "$battery/power_now" 2>/dev/null || echo "0")
if [[ "$power_now" != "0" ]]; then
power_w=$(echo "scale=2; $power_now / 1000000" | bc -l)
power_consumption="$power_w"
break
fi
fi
done
if [[ -n "$power_consumption" ]]; then
echo -e "Current draw: ${power_consumption}W"
else
echo "Power consumption data not available"
fi
# CPU frequency information
if [[ -f /proc/cpuinfo ]]; then
local cpu_freq=$(cat /proc/cpuinfo | grep "cpu MHz" | head -1 | awk '{print $4}')
if [[ -n "$cpu_freq" ]]; then
echo -e "CPU frequency: ${cpu_freq} MHz"
fi
fi
# Load average
local load_avg=$(cat /proc/loadavg | awk '{print $1, $2, $3}')
echo -e "Load average: $load_avg"
# Temperature (if available)
if command -v sensors &> /dev/null; then
local temp=$(sensors | grep "Core 0" | awk '{print $3}' | head -1)
if [[ -n "$temp" ]]; then
echo -e "CPU temperature: $temp"
fi
fi
echo
}
# Function to show system uptime and power efficiency
show_efficiency() {
echo -e "${CYAN}System Efficiency:${NC}"
echo "----------------------------------------"
# Uptime
local uptime_info=$(uptime -p)
echo -e "Uptime: $uptime_info"
# Memory usage
local mem_info=$(free -h | grep "Mem:" | awk '{print "Used: " $3 " / " $2}')
echo -e "Memory: $mem_info"
# Disk activity
if command -v iostat &> /dev/null; then
local disk_usage=$(iostat -d 1 2 | tail -n +4 | head -1 | awk '{print $4 + $5}')
echo -e "Disk I/O: ${disk_usage} KB/s"
fi
echo
}
# Function to provide power saving tips
show_tips() {
echo -e "${CYAN}Power Saving Tips:${NC}"
echo "----------------------------------------"
echo "• Lower screen brightness"
echo "• Close unused applications"
echo "• Disable unused wireless devices"
echo "• Use power saving mode"
echo "• Enable TLP and PowerTOP optimizations"
echo "• Consider using an SSD instead of HDD"
echo
}
# Main function
main() {
# Check if bc is available for calculations
if ! command -v bc &> /dev/null; then
echo "Installing bc for calculations..."
sudo apt update && sudo apt install -y bc
fi
# Clear screen and show header
clear
print_header
# Show all information
get_battery_info
show_tlp_status
show_power_consumption
show_efficiency
show_tips
echo -e "${BLUE}Last updated: $(date)${NC}"
}
# Watch mode - refresh every 5 seconds
if [[ "${1:-}" == "--watch" ]]; then
while true; do
main
sleep 5
done
else
main
fi

198
scripts/install.sh Executable file
View File

@@ -0,0 +1,198 @@
#!/bin/bash
# Battery Life Optimizer - TLP and PowerTOP Installation Script
# For Debian/Ubuntu-based Linux distributions
set -euo pipefail
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Logging function
log() {
echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
}
success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# Check if running as root
check_root() {
if [[ $EUID -eq 0 ]]; then
error "This script should not be run as root!"
error "It will use sudo when necessary."
exit 1
fi
}
# Check if system is supported
check_system() {
if [[ ! -f /etc/debian_version ]] && [[ ! -f /etc/ubuntu_version ]]; then
warning "This script is optimized for Debian/Ubuntu systems."
read -p "Continue anyway? (y/N): " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
exit 1
fi
fi
}
# Update package lists
update_packages() {
log "Updating package lists..."
sudo apt update
success "Package lists updated"
}
# Install TLP
install_tlp() {
log "Installing TLP (Advanced Power Management)..."
# Check if TLP is already installed
if command -v tlp &> /dev/null; then
warning "TLP is already installed"
return 0
fi
# Install TLP and additional packages
sudo apt install -y tlp tlp-rdw
# For ThinkPads, install additional tools
if dmidecode -s system-product-name | grep -qi "thinkpad"; then
log "ThinkPad detected, installing additional tools..."
sudo apt install -y tp-smapi-dkms acpi-call-dkms
fi
# Enable and start TLP service
sudo systemctl enable tlp.service
sudo systemctl start tlp.service
success "TLP installed and configured"
}
# Install PowerTOP
install_powertop() {
log "Installing PowerTOP..."
# Check if PowerTOP is already installed
if command -v powertop &> /dev/null; then
warning "PowerTOP is already installed"
return 0
fi
sudo apt install -y powertop
success "PowerTOP installed"
}
# Setup PowerTOP service for automatic tuning
setup_powertop_service() {
log "Setting up PowerTOP auto-tune service..."
# Create systemd service file for PowerTOP
sudo tee /etc/systemd/system/powertop.service > /dev/null <<EOF
[Unit]
Description=PowerTOP auto tune
After=multi-user.target
[Service]
Type=oneshot
ExecStart=/usr/sbin/powertop --auto-tune
RemainAfterExit=true
[Install]
WantedBy=multi-user.target
EOF
# Enable the service
sudo systemctl daemon-reload
sudo systemctl enable powertop.service
success "PowerTOP auto-tune service configured"
}
# Backup existing TLP configuration
backup_tlp_config() {
local tlp_config="/etc/tlp.conf"
local backup_file="/etc/tlp.conf.backup.$(date +%Y%m%d_%H%M%S)"
if [[ -f "$tlp_config" ]]; then
log "Backing up existing TLP configuration..."
sudo cp "$tlp_config" "$backup_file"
success "TLP configuration backed up to $backup_file"
fi
}
# Apply optimized TLP configuration
apply_tlp_config() {
log "Applying optimized TLP configuration..."
local config_file="../config/tlp.conf"
if [[ -f "$config_file" ]]; then
sudo cp "$config_file" /etc/tlp.conf
success "TLP configuration applied"
else
warning "Optimized TLP config file not found. Using default configuration."
fi
}
# Install additional power management tools
install_additional_tools() {
log "Installing additional power management tools..."
sudo apt install -y \
laptop-mode-tools \
thermald \
cpufrequtils \
smartmontools \
ethtool
success "Additional tools installed"
}
# Main installation function
main() {
log "Starting Battery Life Optimizer installation..."
check_root
check_system
update_packages
install_tlp
install_powertop
setup_powertop_service
install_additional_tools
backup_tlp_config
apply_tlp_config
# Start TLP
log "Starting TLP service..."
sudo tlp start
success "Installation completed successfully!"
echo
log "Next steps:"
echo "1. Run 'tlp-stat' to check TLP status"
echo "2. Run 'sudo powertop' to analyze power consumption"
echo "3. Reboot your system for all changes to take effect"
echo "4. Use the monitoring scripts in the scripts/ directory"
}
# Run main function if script is executed directly
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi

262
scripts/powertop-analyze.sh Executable file
View File

@@ -0,0 +1,262 @@
#!/bin/bash
# PowerTOP Analysis Tool
# Generates detailed power consumption reports and recommendations
set -euo pipefail
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color
# Default values
REPORT_DIR="$HOME/.battery-optimizer/reports"
DURATION=60
OUTPUT_FORMAT="html"
# Function to show usage
show_usage() {
echo "PowerTOP Analysis Tool"
echo
echo "Usage: $0 [OPTIONS]"
echo
echo "Options:"
echo " -d, --duration SECONDS Analysis duration in seconds (default: 60)"
echo " -o, --output DIR Output directory (default: ~/.battery-optimizer/reports)"
echo " -f, --format FORMAT Output format: html, csv, txt (default: html)"
echo " -a, --auto-tune Apply PowerTOP auto-tune (requires sudo)"
echo " -s, --show-report Show latest report in browser"
echo " -h, --help Show this help message"
echo
echo "Examples:"
echo " $0 Generate 60-second report"
echo " $0 -d 120 -f html Generate 2-minute HTML report"
echo " $0 -a Apply auto-tune optimizations"
echo " $0 -s Show latest report"
}
# Function to check dependencies
check_dependencies() {
if ! command -v powertop &> /dev/null; then
echo -e "${RED}Error: PowerTOP is not installed${NC}"
echo "Please run the installation script first: ./scripts/install.sh"
exit 1
fi
}
# Function to create report directory
create_report_dir() {
if [[ ! -d "$REPORT_DIR" ]]; then
mkdir -p "$REPORT_DIR"
echo -e "${GREEN}Created report directory: $REPORT_DIR${NC}"
fi
}
# Function to run PowerTOP analysis
run_analysis() {
local duration=$1
local output_file="$2"
echo -e "${BLUE}Running PowerTOP analysis for $duration seconds...${NC}"
echo "This requires sudo privileges for hardware access."
echo
# Create a temporary file for PowerTOP output
local temp_file=$(mktemp)
case "$OUTPUT_FORMAT" in
"html")
sudo powertop --html="$output_file" --time="$duration"
;;
"csv")
sudo powertop --csv="$output_file" --time="$duration"
;;
"txt")
sudo powertop --time="$duration" > "$temp_file" 2>&1
cp "$temp_file" "$output_file"
rm "$temp_file"
;;
esac
if [[ -f "$output_file" ]]; then
echo -e "${GREEN}Analysis complete! Report saved to: $output_file${NC}"
# Show file size
local file_size=$(du -h "$output_file" | cut -f1)
echo -e "${CYAN}Report size: $file_size${NC}"
return 0
else
echo -e "${RED}Error: Failed to generate report${NC}"
return 1
fi
}
# Function to apply auto-tune
apply_auto_tune() {
echo -e "${YELLOW}Applying PowerTOP auto-tune optimizations...${NC}"
echo "This will modify system power settings."
read -p "Continue? (y/N): " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
sudo powertop --auto-tune
echo -e "${GREEN}Auto-tune applied successfully${NC}"
echo "Note: These settings are temporary and will reset on reboot"
echo "To make them permanent, consider adding them to startup scripts"
else
echo "Auto-tune cancelled"
fi
}
# Function to show latest report
show_latest_report() {
local latest_html=$(find "$REPORT_DIR" -name "*.html" -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -d' ' -f2-)
if [[ -n "$latest_html" && -f "$latest_html" ]]; then
echo -e "${GREEN}Opening latest report: $latest_html${NC}"
# Try different browsers
if command -v xdg-open &> /dev/null; then
xdg-open "$latest_html"
elif command -v firefox &> /dev/null; then
firefox "$latest_html" &
elif command -v chromium &> /dev/null; then
chromium "$latest_html" &
elif command -v google-chrome &> /dev/null; then
google-chrome "$latest_html" &
else
echo "No suitable browser found. Please open manually:"
echo "$latest_html"
fi
else
echo -e "${YELLOW}No HTML reports found in $REPORT_DIR${NC}"
echo "Generate a report first with: $0 -f html"
fi
}
# Function to show quick summary
show_quick_summary() {
echo -e "${CYAN}Quick PowerTOP Summary:${NC}"
echo "----------------------------------------"
# Show current power consumption estimate
sudo powertop --time=1 2>/dev/null | grep -E "(The battery reports|Wh)" | head -5
echo
echo -e "${CYAN}Top power consumers (run full analysis for details):${NC}"
sudo powertop --time=1 2>/dev/null | grep -A 10 "Top 10 power consumers" | tail -10
}
# Function to generate filename
generate_filename() {
local timestamp=$(date +"%Y%m%d_%H%M%S")
local hostname=$(hostname -s)
echo "powertop_${hostname}_${timestamp}.${OUTPUT_FORMAT}"
}
# Main function
main() {
local auto_tune=false
local show_report=false
local quick_summary=false
# Parse command line arguments
while [[ $# -gt 0 ]]; do
case $1 in
-d|--duration)
DURATION="$2"
shift 2
;;
-o|--output)
REPORT_DIR="$2"
shift 2
;;
-f|--format)
OUTPUT_FORMAT="$2"
shift 2
;;
-a|--auto-tune)
auto_tune=true
shift
;;
-s|--show-report)
show_report=true
shift
;;
-q|--quick)
quick_summary=true
shift
;;
-h|--help)
show_usage
exit 0
;;
*)
echo "Unknown option: $1"
show_usage
exit 1
;;
esac
done
# Validate format
if [[ ! "$OUTPUT_FORMAT" =~ ^(html|csv|txt)$ ]]; then
echo -e "${RED}Error: Invalid output format '$OUTPUT_FORMAT'${NC}"
echo "Supported formats: html, csv, txt"
exit 1
fi
# Check dependencies
check_dependencies
# Handle special actions
if [[ "$show_report" == true ]]; then
show_latest_report
exit 0
fi
if [[ "$auto_tune" == true ]]; then
apply_auto_tune
exit 0
fi
if [[ "$quick_summary" == true ]]; then
show_quick_summary
exit 0
fi
# Create report directory
create_report_dir
# Generate output filename
local output_file="$REPORT_DIR/$(generate_filename)"
# Run analysis
if run_analysis "$DURATION" "$output_file"; then
echo
echo -e "${CYAN}Analysis Summary:${NC}"
echo "• Report location: $output_file"
echo "• Analysis duration: $DURATION seconds"
echo "• Format: $OUTPUT_FORMAT"
if [[ "$OUTPUT_FORMAT" == "html" ]]; then
echo
echo "To view the report, run: $0 --show-report"
echo "Or open manually: firefox '$output_file'"
fi
echo
echo -e "${YELLOW}Tip: Run '$0 --auto-tune' to apply recommended optimizations${NC}"
fi
}
# Run main function if script is executed directly
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi

316
scripts/tlp-manager.sh Executable file
View File

@@ -0,0 +1,316 @@
#!/bin/bash
# TLP Status and Configuration Tool
# Displays TLP status and provides configuration management
set -euo pipefail
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color
# Function to show usage
show_usage() {
echo "TLP Status and Configuration Tool"
echo
echo "Usage: $0 [OPTIONS]"
echo
echo "Options:"
echo " -s, --status Show TLP status (default)"
echo " -c, --config Show TLP configuration"
echo " -r, --recommendations Show optimization recommendations"
echo " -t, --toggle-mode Toggle between AC/BAT mode"
echo " -b, --battery-info Show detailed battery information"
echo " -p, --profile PROFILE Apply power profile (powersave|balanced|performance)"
echo " -h, --help Show this help message"
echo
echo "Examples:"
echo " $0 Show TLP status"
echo " $0 -c Show configuration"
echo " $0 -p powersave Apply power saving profile"
echo " $0 -r Show recommendations"
}
# Function to check if TLP is installed
check_tlp() {
if ! command -v tlp &> /dev/null; then
echo -e "${RED}Error: TLP is not installed${NC}"
echo "Please run the installation script first: ./scripts/install.sh"
exit 1
fi
}
# Function to show TLP status
show_status() {
echo -e "${CYAN}TLP Status Information:${NC}"
echo "========================================"
echo
# Basic TLP status
echo -e "${BLUE}System Status:${NC}"
tlp-stat -s
echo
# Power source
echo -e "${BLUE}Power Source:${NC}"
tlp-stat | grep -A 5 "Power source"
echo
# TLP service status
echo -e "${BLUE}TLP Service:${NC}"
systemctl is-active tlp.service && echo -e "Status: ${GREEN}Active${NC}" || echo -e "Status: ${RED}Inactive${NC}"
systemctl is-enabled tlp.service && echo -e "Enabled: ${GREEN}Yes${NC}" || echo -e "Enabled: ${RED}No${NC}"
echo
# Current power profile
echo -e "${BLUE}Current Power Profile:${NC}"
tlp-stat | grep -E "Mode|operation mode" | head -3
echo
}
# Function to show TLP configuration
show_config() {
echo -e "${CYAN}TLP Configuration:${NC}"
echo "========================================"
echo
# CPU settings
echo -e "${BLUE}CPU Settings:${NC}"
tlp-stat -p
echo
# Disk settings
echo -e "${BLUE}Disk Settings:${NC}"
tlp-stat -d
echo
# Graphics settings
echo -e "${BLUE}Graphics Settings:${NC}"
tlp-stat -g
echo
# USB settings
echo -e "${BLUE}USB Settings:${NC}"
tlp-stat -u
echo
}
# Function to show battery information
show_battery_info() {
echo -e "${CYAN}Battery Information:${NC}"
echo "========================================"
echo
tlp-stat -b
echo
# Additional battery health info
if [[ -d "/sys/class/power_supply/BAT0" ]]; then
echo -e "${BLUE}Battery Health Details:${NC}"
local cycle_count=$(cat /sys/class/power_supply/BAT0/cycle_count 2>/dev/null || echo "N/A")
local manufacture_date=$(cat /sys/class/power_supply/BAT0/manufacture_date 2>/dev/null || echo "N/A")
local serial=$(cat /sys/class/power_supply/BAT0/serial_number 2>/dev/null || echo "N/A")
echo "Cycle count: $cycle_count"
echo "Manufacture date: $manufacture_date"
echo "Serial number: $serial"
echo
fi
}
# Function to show recommendations
show_recommendations() {
echo -e "${CYAN}Power Optimization Recommendations:${NC}"
echo "========================================"
echo
# Check current settings and provide recommendations
local current_governor=$(cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor 2>/dev/null || echo "N/A")
local current_brightness=$(cat /sys/class/backlight/*/brightness 2>/dev/null | head -1 || echo "N/A")
local max_brightness=$(cat /sys/class/backlight/*/max_brightness 2>/dev/null | head -1 || echo "1")
echo -e "${BLUE}Current System State:${NC}"
echo "CPU Governor: $current_governor"
if [[ "$current_brightness" != "N/A" && "$max_brightness" != "1" ]]; then
local brightness_percent=$(( current_brightness * 100 / max_brightness ))
echo "Screen brightness: ${brightness_percent}%"
if [[ $brightness_percent -gt 70 ]]; then
echo -e "${YELLOW}• Consider reducing screen brightness to save power${NC}"
fi
fi
echo
echo -e "${BLUE}Recommendations:${NC}"
# Check if on battery
local power_source=$(tlp-stat -s | grep "Power source" | awk '{print $3}' || echo "unknown")
if [[ "$power_source" == "battery" ]]; then
echo -e "${GREEN}✓ Running on battery - power saving mode active${NC}"
# Check governor
if [[ "$current_governor" != "powersave" ]]; then
echo -e "${YELLOW}• Consider switching to 'powersave' CPU governor${NC}"
fi
# Check for running services
echo -e "${YELLOW}• Close unnecessary applications${NC}"
echo -e "${YELLOW}• Disable unused wireless interfaces${NC}"
echo -e "${YELLOW}• Enable laptop mode if available${NC}"
else
echo -e "${BLUE}Running on AC power${NC}"
echo -e "• Power saving less critical, but still beneficial"
fi
# Check for power-hungry processes
echo
echo -e "${BLUE}Power-hungry processes (top CPU users):${NC}"
ps aux --sort=-%cpu | head -6 | awk 'NR>1{printf "%-20s %s%%\n", $11, $3}'
echo
echo -e "${BLUE}Quick optimization commands:${NC}"
echo "• sudo tlp bat # Force battery mode"
echo "• sudo tlp ac # Force AC mode"
echo "• sudo powertop --auto-tune # Apply PowerTOP optimizations"
echo
}
# Function to toggle power mode
toggle_mode() {
local current_mode=$(tlp-stat -s | grep "Mode" | awk '{print $2}' | tr -d '[]')
echo -e "${CYAN}Current mode: $current_mode${NC}"
if [[ "$current_mode" == "AC" ]]; then
echo "Switching to battery mode..."
sudo tlp bat
echo -e "${GREEN}Switched to battery mode${NC}"
else
echo "Switching to AC mode..."
sudo tlp ac
echo -e "${GREEN}Switched to AC mode${NC}"
fi
}
# Function to apply power profile
apply_profile() {
local profile=$1
case $profile in
"powersave")
echo -e "${CYAN}Applying power saving profile...${NC}"
sudo tlp bat
# Additional power saving commands
echo 'powersave' | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor > /dev/null
echo -e "${GREEN}Power saving profile applied${NC}"
;;
"balanced")
echo -e "${CYAN}Applying balanced profile...${NC}"
sudo tlp start
echo 'ondemand' | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor > /dev/null 2>&1 || \
echo 'schedutil' | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor > /dev/null
echo -e "${GREEN}Balanced profile applied${NC}"
;;
"performance")
echo -e "${CYAN}Applying performance profile...${NC}"
sudo tlp ac
echo 'performance' | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor > /dev/null
echo -e "${GREEN}Performance profile applied${NC}"
echo -e "${YELLOW}Note: This will increase power consumption${NC}"
;;
*)
echo -e "${RED}Invalid profile: $profile${NC}"
echo "Valid profiles: powersave, balanced, performance"
exit 1
;;
esac
}
# Main function
main() {
local action="status"
local profile=""
# Parse command line arguments
while [[ $# -gt 0 ]]; do
case $1 in
-s|--status)
action="status"
shift
;;
-c|--config)
action="config"
shift
;;
-r|--recommendations)
action="recommendations"
shift
;;
-t|--toggle-mode)
action="toggle"
shift
;;
-b|--battery-info)
action="battery"
shift
;;
-p|--profile)
action="profile"
profile="$2"
shift 2
;;
-h|--help)
show_usage
exit 0
;;
*)
echo "Unknown option: $1"
show_usage
exit 1
;;
esac
done
# Check if TLP is installed
check_tlp
# Execute requested action
case $action in
"status")
show_status
;;
"config")
show_config
;;
"recommendations")
show_recommendations
;;
"toggle")
toggle_mode
;;
"battery")
show_battery_info
;;
"profile")
if [[ -z "$profile" ]]; then
echo -e "${RED}Error: Profile name required${NC}"
show_usage
exit 1
fi
apply_profile "$profile"
;;
esac
}
# Run main function if script is executed directly
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi

116
scripts/uninstall.sh Executable file
View File

@@ -0,0 +1,116 @@
#!/bin/bash
# Uninstall script for Battery Life Optimizer tools
set -euo pipefail
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
log() {
echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
}
success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# Check if running as root
check_root() {
if [[ $EUID -eq 0 ]]; then
error "This script should not be run as root!"
error "It will use sudo when necessary."
exit 1
fi
}
# Restore TLP configuration backup
restore_tlp_config() {
local backup_pattern="/etc/tlp.conf.backup.*"
local latest_backup=$(ls -t $backup_pattern 2>/dev/null | head -n1)
if [[ -n "$latest_backup" && -f "$latest_backup" ]]; then
log "Restoring TLP configuration from backup..."
sudo cp "$latest_backup" /etc/tlp.conf
success "TLP configuration restored from $latest_backup"
else
warning "No TLP configuration backup found"
fi
}
# Remove PowerTOP service
remove_powertop_service() {
log "Removing PowerTOP auto-tune service..."
if systemctl is-enabled powertop.service &>/dev/null; then
sudo systemctl disable powertop.service
sudo systemctl stop powertop.service
fi
if [[ -f /etc/systemd/system/powertop.service ]]; then
sudo rm /etc/systemd/system/powertop.service
sudo systemctl daemon-reload
fi
success "PowerTOP service removed"
}
# Uninstall packages
uninstall_packages() {
log "Removing installed packages..."
# Ask for confirmation
warning "This will remove TLP, PowerTOP, and related packages"
read -p "Are you sure? (y/N): " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
sudo apt remove --purge -y \
tlp \
tlp-rdw \
powertop \
tp-smapi-dkms \
acpi-call-dkms \
laptop-mode-tools \
thermald \
cpufrequtils
sudo apt autoremove -y
success "Packages removed"
else
warning "Package removal cancelled"
fi
}
# Main uninstall function
main() {
log "Starting Battery Life Optimizer uninstallation..."
check_root
remove_powertop_service
restore_tlp_config
uninstall_packages
success "Uninstallation completed!"
echo
log "System restored to previous state"
warning "Reboot recommended to ensure all changes take effect"
}
# Run main function if script is executed directly
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi