Smart Electrical Load Management

System

Complete Implementation Guide with Circuit Diagram

This comprehensive guide provides detailed instructions for building an AI-powered
system that monitors and manages your vehicle's electrical loads to optimize
performance and prevent battery drain.

Table of Contents
1. Overview
2. Materials List
3. Circuit Diagram Explanation
4. Hardware Assembly
5. Software Setup
6. Installation in Vehicle
7. AI Enhancement
 8. Testing and Calibration
9. Advanced Features
10. Troubleshooting
11. Future Enhancements
12. Resources

Overview
The Smart Electrical Load Management System is an AI-powered device that monitors
the electrical loads in your vehicle, predicts power requirements, and intelligently
manages the distribution of electrical power. It can prevent battery drain, reduce
alternator stress, and optimize the performance of your vehicle's electrical system.

Key Features:

• Real-time monitoring of battery voltage and current draw from multiple systems
• AI-based prediction of electrical load requirements
• Automatic prioritization and management of electrical systems
• Data logging for analysis and pattern recognition
• Temperature and humidity monitoring to adjust predictions
• Integration with home automation systems (optional)

Materials List
• Arduino Mega 2560 or ESP32 development board
• 4-8 ACS712 current sensor modules (30A version recommended)
• Voltage divider resistors (10kΩ and 2.2kΩ pairs)
• 8-channel relay module (automotive-rated)
• 16x2 LCD display with I2C interface
• SD card module
• DS3231 real-time clock module
• DHT22 temperature/humidity sensor
• Automotive-grade wire (various gauges)
• Crimp connectors and heat shrink tubing
• Automotive fuse holders and appropriate fuses
• Project enclosure (waterproof if mounted in engine bay)
• Breadboard and jumper wires (for prototyping)
• Terminal blocks
• 5V voltage regulator (LM7805 or similar)
• Capacitors (100μF, 10μF, 0.1μF)
Circuit Diagram Explanation
The circuit diagram shows all components and connections needed for the Smart
Electrical Load Management System:

Key Components:

1. Central Controller - Arduino Mega or ESP32 microcontroller that processes all

sensor data and controls the relays.
2. Current Sensors - Four ACS712 current sensors to monitor the electrical
consumption of different vehicle systems (headlights, HVAC, radio, and
accessories).
3. Voltage Divider - For safely measuring the 12V battery voltage using the
microcontroller's analog input.
4. Relay Module - 8-channel relay module that can control the power to non-
essential electrical systems when needed.
5. Support Components:
6. 5V Regulator - Converts vehicle 12V to 5V for powering the electronics
7. LCD Display - For showing system status and alerts
8. SD Card Module - For data logging
9. RTC Module - For accurate timekeeping
10. DHT22 Sensor - For monitoring temperature and humidity

Connection Types:

• Power connections (thick black and red lines)

• Analog sensor connections (green lines)
• Digital control connections (red lines to relay module)
• Communication buses (I2C and SPI)
• Ground connections (dashed lines)

Important Notes:

1. All ground connections are shown with dashed lines

2. Use appropriate fuses for all connections to vehicle power
3. Current sensors must be installed in series with load circuits
4. Relay NC terminals connect to loads for fail-safe operation
5. Use shielded cables for sensor connections to reduce noise
Hardware Assembly

Power Supply Circuit

1. Create a stable power supply for the electronics:

2. Connect the vehicle's 12V supply to the input of the LM7805 voltage regulator
3. Add a 100μF capacitor between the input and ground
4. Add a 10μF capacitor between the output and ground
5. The output will provide a stable 5V for the Arduino/ESP32 and sensors

Current Sensor Circuits

1. For each electrical system you want to monitor (e.g., headlights, HVAC, radio):
2. Identify the positive wire for that system
3. Cut the wire and insert the ACS712 current sensor in series
4. Connect the VCC pin of each ACS712 to the 5V supply
5. Connect the GND pin to the common ground
6. Connect the OUT pin to an analog input on the Arduino/ESP32
7. Label each sensor connection for easy identification

Voltage Monitoring Circuit

1. Create a voltage divider to monitor battery voltage:

2. Connect a 10kΩ and 2.2kΩ resistor in series
3. Connect the junction between resistors to an analog input
4. Connect the 10kΩ end to the positive battery terminal
5. Connect the 2.2kΩ end to ground

Relay Module

1. Connect the relay module to control non-essential electrical systems:

2. Connect the VCC pin to the 5V supply
3. Connect the GND pin to the common ground
4. Connect each IN pin to a digital output pin on the Arduino/ESP32
5. Connect the relay common (COM) terminals to the vehicle's positive supply
6. Connect the normally closed (NC) terminals to the original positive wires of each
controlled system
7. Use appropriate gauge wire based on the current requirements of each system

Additional Sensors

1. Connect the DHT22 temperature/humidity sensor:

 2. VCC to 5V
3. GND to ground
4. DATA to a digital pin on the Arduino/ESP32

5. Add a 10kΩ pull-up resistor between VCC and DATA

6. Connect the DS3231 real-time clock module:

7. VCC to 5V
8. GND to ground
9. SDA to the SDA pin on the Arduino/ESP32

10. SCL to the SCL pin on the Arduino/ESP32

11. Connect the LCD display:

12. VCC to 5V
13. GND to ground
14. SDA to the SDA pin on the Arduino/ESP32

15. SCL to the SCL pin on the Arduino/ESP32

16. Connect the SD card module:

17. VCC to 5V
18. GND to ground
19. MOSI, MISO, SCK, and CS to the corresponding SPI pins on the Arduino/ESP32

Software Setup

Install Required Libraries

1. Install the Arduino IDE from arduino.cc

2. Install the following libraries through the Library Manager:
3. Wire (for I2C communication)
4. LiquidCrystal_I2C (for the LCD display)
5. SD (for SD card operations)
6. RTClib (for the real-time clock)
7. DHT (for the temperature/humidity sensor)
8. ArduinoJson (for data formatting)

Arduino Code

Create a new sketch with the following code:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <SD.h>
#include <SPI.h>
#include <RTClib.h>
#include <DHT.h>
#include <ArduinoJson.h>

// Pin definitions
#define BATTERY_VOLTAGE_PIN A0
#define HEADLIGHTS_CURRENT_PIN A1
#define HVAC_CURRENT_PIN A2
#define RADIO_CURRENT_PIN A3
#define ACCESSORIES_CURRENT_PIN A4
// Add more current sensor pins as needed

#define HEADLIGHTS_RELAY_PIN 22
#define HVAC_RELAY_PIN 24
#define RADIO_RELAY_PIN 26
#define ACCESSORIES_RELAY_PIN 28
// Add more relay pins as needed

#define DHT_PIN 30
#define DHT_TYPE DHT22
#define SD_CS_PIN 53

// Constants
#define VOLTAGE_REFERENCE 5.0
#define VOLTAGE_DIVIDER_RATIO 5.54545 // (10k + 2.2k) / 2.2k
#define CURRENT_SENSOR_SENSITIVITY 0.066 // V/A for ACS712 30A
#define CURRENT_SENSOR_OFFSET 2.5 // Offset voltage (0A point)
#define SAMPLE_INTERVAL 1000 // ms
#define LOG_INTERVAL 60000 // Log data every minute (ms)
#define LOAD_MANAGEMENT_INTERVAL 5000 // Check and manage loads every 5
seconds

// System priorities (1-10, 10 being highest priority)

#define HEADLIGHTS_PRIORITY 10
#define HVAC_PRIORITY 7
#define RADIO_PRIORITY 3
#define ACCESSORIES_PRIORITY 2

// Threshold for load management

#define LOW_VOLTAGE_THRESHOLD 12.2 // V
#define CRITICAL_VOLTAGE_THRESHOLD 11.8 // V
#define MAX_TOTAL_CURRENT 80.0 // A

// Global variables
float batteryVoltage = 0.0;
float headlightsCurrent = 0.0;
float hvacCurrent = 0.0;
float radioCurrent = 0.0;
float accessoriesCurrent = 0.0;
float totalCurrent = 0.0;
float temperature = 0.0;
float humidity = 0.0;

bool engineRunning = false;

bool headlightsOn = false;
bool hvacOn = false;
bool radioOn = false;
bool accessoriesOn = false;

bool headlightsControlled = false;

bool hvacControlled = false;
bool radioControlled = false;
bool accessoriesControlled = false;

unsigned long lastSampleTime = 0;

unsigned long lastLogTime = 0;
unsigned long lastLoadManagementTime = 0;
String dataFileName = "";

// Initialize objects
LiquidCrystal_I2C lcd(0x27, 16, 2); // Set the LCD address to 0x27 for a 16x2 display
RTC_DS3231 rtc;
DHT dht(DHT_PIN, DHT_TYPE);

// Load prediction variables

float predictedLoad = 0.0;
float loadHistory[24] = {0}; // Store 24 hours of average load
int currentHour = 0;
int loadHistoryCount = 0;

void setup() {
// Initialize serial communication
Serial.begin(9600);
Serial.println("Smart Electrical Load Management System");

// Initialize pins
pinMode(HEADLIGHTS_RELAY_PIN, OUTPUT);
pinMode(HVAC_RELAY_PIN, OUTPUT);
pinMode(RADIO_RELAY_PIN, OUTPUT);
pinMode(ACCESSORIES_RELAY_PIN, OUTPUT);

// Set all relays to pass-through mode initially

digitalWrite(HEADLIGHTS_RELAY_PIN, HIGH);
digitalWrite(HVAC_RELAY_PIN, HIGH);
digitalWrite(RADIO_RELAY_PIN, HIGH);
digitalWrite(ACCESSORIES_RELAY_PIN, HIGH);

// Initialize LCD
lcd.init();
 lcd.backlight();
lcd.print("Load Management");
lcd.setCursor(0, 1);
lcd.print("Initializing...");

// Initialize RTC
if (!rtc.begin()) {
Serial.println("Couldn't find RTC");
lcd.clear();
lcd.print("RTC Error!");
while (1); // Don't proceed if RTC fails
}

if (rtc.lostPower()) {
Serial.println("RTC lost power, setting the time!");
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}

// Initialize DHT sensor

dht.begin();

// Initialize SD card
Serial.print("Initializing SD card...");
if (!SD.begin(SD_CS_PIN)) {
Serial.println("SD card initialization failed!");
lcd.clear();
lcd.print("SD Card Failed!");
delay(2000);
// Continue without SD card
} else {
Serial.println("SD card initialized.");

// Create a new file name with timestamp

DateTime now = rtc.now();
dataFileName = String(now.year()) + String(now.month()) + String(now.day()) +
".csv";

// Write header to the file if it doesn't exist

if (!SD.exists(dataFileName)) {
File dataFile = SD.open(dataFileName, FILE_WRITE);
if (dataFile) {

dataFile.println("Timestamp,BatteryVoltage,HeadlightsCurrent,HVACCurrent,RadioCurrent,Acce
dataFile.close();
Serial.println("Created log file: " + dataFileName);
} else {
Serial.println("Error opening file!");
}
}
}

// Load historical data if available

 loadHistoricalData();

lcd.clear();
lcd.print("System Ready");
delay(1000);
}

void loop() {
unsigned long currentTime = millis();

// Sample data at regular intervals

if (currentTime - lastSampleTime >= SAMPLE_INTERVAL) {
lastSampleTime = currentTime;

// Read sensors
readSensors();

// Detect if engine is running based on battery voltage

detectEngineStatus();

// Detect which systems are on based on current draw

detectSystemStatus();

// Update LCD with current status

updateLCD();

// Print to serial for debugging

printStatus();
}

// Manage electrical loads if needed

if (currentTime - lastLoadManagementTime >= LOAD_MANAGEMENT_INTERVAL) {
lastLoadManagementTime = currentTime;

// Predict load based on historical data and current conditions

predictLoad();

// Manage loads based on current conditions and predictions

manageLoads();
}

// Log data at regular intervals

if (currentTime - lastLogTime >= LOG_INTERVAL) {
lastLogTime = currentTime;
logData();

// Update historical data

updateHistoricalData();
}
}

void readSensors() {
 // Read and calculate battery voltage
int batteryRaw = analogRead(BATTERY_VOLTAGE_PIN);
batteryVoltage = (batteryRaw / 1023.0) * VOLTAGE_REFERENCE *
VOLTAGE_DIVIDER_RATIO;

// Read and calculate current for each system

headlightsCurrent = readCurrent(HEADLIGHTS_CURRENT_PIN);
hvacCurrent = readCurrent(HVAC_CURRENT_PIN);
radioCurrent = readCurrent(RADIO_CURRENT_PIN);
accessoriesCurrent = readCurrent(ACCESSORIES_CURRENT_PIN);

// Calculate total current

totalCurrent = headlightsCurrent + hvacCurrent + radioCurrent +
accessoriesCurrent;

// Read temperature and humidity

humidity = dht.readHumidity();
temperature = dht.readTemperature();

// Check if any reads failed

if (isnan(humidity) || isnan(temperature)) {
Serial.println("Failed to read from DHT sensor!");
humidity = 0;
temperature = 0;
}
}

float readCurrent(int pin) {

// Take multiple readings for better accuracy
float total = 0;
for (int i = 0; i < 10; i++) {
int rawValue = analogRead(pin);
float voltage = (rawValue / 1023.0) * VOLTAGE_REFERENCE;
total += (voltage - CURRENT_SENSOR_OFFSET) / CURRENT_SENSOR_SENSITIVITY;
delay(1);
}
float current = total / 10.0;

// Return absolute value (direction doesn't matter for our application)

return abs(current);
}

void detectEngineStatus() {
// Detect if engine is running based on battery voltage
// Typically, battery voltage is higher when the engine is running
if (batteryVoltage > 13.0) {
engineRunning = true;
} else if (batteryVoltage < 12.5) {
engineRunning = false;
}
// If voltage is between 12.5 and 13.0, maintain previous state to avoid oscillation
}
void detectSystemStatus() {
// Detect which systems are on based on current draw
headlightsOn = (headlightsCurrent > 0.5); // Adjust threshold based on your system
hvacOn = (hvacCurrent > 0.5);
radioOn = (radioCurrent > 0.2);
accessoriesOn = (accessoriesCurrent > 0.2);
}

void updateLCD() {
lcd.clear();

// First line: Battery voltage and total current

lcd.print("B:");
lcd.print(batteryVoltage, 1);
lcd.print("V I:");
lcd.print(totalCurrent, 1);
lcd.print("A");

// Second line: Engine status and load management status

lcd.setCursor(0, 1);
lcd.print(engineRunning ? "ENG:ON" : "ENG:OFF");
lcd.print(" ");

bool loadManagementActive = headlightsControlled || hvacControlled ||

radioControlled || accessoriesControlled;
lcd.print(loadManagementActive ? "LM:ON" : "LM:OFF");
}

void printStatus() {
Serial.print("Battery: ");
Serial.print(batteryVoltage, 2);
Serial.print("V, Total Current: ");
Serial.print(totalCurrent, 2);
Serial.print("A, Engine: ");
Serial.print(engineRunning ? "Running" : "Off");
Serial.print(", Temp: ");
Serial.print(temperature, 1);
Serial.print("C, Humidity: ");
Serial.print(humidity, 1);
Serial.println("%");

Serial.print("Headlights: ");
Serial.print(headlightsOn ? "On" : "Off");
Serial.print(" (");
Serial.print(headlightsCurrent, 2);
Serial.print("A), HVAC: ");
Serial.print(hvacOn ? "On" : "Off");
Serial.print(" (");
Serial.print(hvacCurrent, 2);
Serial.print("A), Radio: ");
Serial.print(radioOn ? "On" : "Off");
 Serial.print(" (");
Serial.print(radioCurrent, 2);
Serial.print("A), Accessories: ");
Serial.print(accessoriesOn ? "On" : "Off");
Serial.print(" (");
Serial.print(accessoriesCurrent, 2);
Serial.println("A)");

Serial.print("Load Management: ");

Serial.print(headlightsControlled ? "Headlights " : "");
Serial.print(hvacControlled ? "HVAC " : "");
Serial.print(radioControlled ? "Radio " : "");
Serial.println(accessoriesControlled ? "Accessories" : "");

Serial.print("Predicted Load: ");

Serial.print(predictedLoad, 2);
Serial.println("A");

Serial.println();
}

void predictLoad() {
// Get current hour
DateTime now = rtc.now();
int hour = now.hour();

// Use historical data for the current hour if available

if (loadHistoryCount > 0) {
predictedLoad = loadHistory[hour];

// Adjust prediction based on current conditions

if (temperature > 30) {
// Hot weather might increase HVAC usage
predictedLoad *= 1.2;
} else if (temperature < 5) {
// Cold weather might increase electrical load (heaters, etc.)
predictedLoad *= 1.3;
}

// Adjust for night time (headlights)

if (hour < 6 || hour > 18) {
predictedLoad += 5.0; // Assume headlights add about 5A
}
} else {
// If no historical data, use current load as prediction
predictedLoad = totalCurrent;
}

// Ensure prediction is reasonable

if (predictedLoad < totalCurrent) {
predictedLoad = totalCurrent;
}
}

void manageLoads() {
// Reset control flags
bool needToManageLoads = false;
headlightsControlled = false;
hvacControlled = false;
radioControlled = false;
accessoriesControlled = false;

// Check if load management is needed

if (!engineRunning && batteryVoltage < LOW_VOLTAGE_THRESHOLD) {
needToManageLoads = true;
} else if (totalCurrent > MAX_TOTAL_CURRENT) {
needToManageLoads = true;
} else if (predictedLoad > MAX_TOTAL_CURRENT && totalCurrent > 0.7 *
MAX_TOTAL_CURRENT) {
// If we predict we'll exceed max current soon and we're already at 70% capacity
needToManageLoads = true;
}

if (needToManageLoads) {
// Create an array of systems to manage, sorted by priority
struct System {
int priority;
float current;
bool *controlFlag;
int relayPin;
bool isOn;
};

System systems[] = {
{ACCESSORIES_PRIORITY, accessoriesCurrent, &accessoriesControlled,
ACCESSORIES_RELAY_PIN, accessoriesOn},
{RADIO_PRIORITY, radioCurrent, &radioControlled, RADIO_RELAY_PIN,
radioOn},
{HVAC_PRIORITY, hvacCurrent, &hvacControlled, HVAC_RELAY_PIN, hvacOn},
{HEADLIGHTS_PRIORITY, headlightsCurrent, &headlightsControlled,
HEADLIGHTS_RELAY_PIN, headlightsOn}
};

// Sort systems by priority (lowest first)

for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3 - i; j++) {
if (systems[j].priority > systems[j + 1].priority) {
System temp = systems[j];
systems[j] = systems[j + 1];
systems[j + 1] = temp;
}
}
}
 // Start turning off systems from lowest priority until we're under threshold
float currentLoad = totalCurrent;
for (int i = 0; i < 4; i++) {
if (systems[i].isOn) {
// Turn off this system
digitalWrite(systems[i].relayPin, LOW);
*(systems[i].controlFlag) = true;
currentLoad -= systems[i].current;

// If we're now under threshold, stop

if (currentLoad < 0.8 * MAX_TOTAL_CURRENT) {
break;
}
}
}
} else {
// If load management is not needed, ensure all systems are on
digitalWrite(HEADLIGHTS_RELAY_PIN, HIGH);
digitalWrite(HVAC_RELAY_PIN, HIGH);
digitalWrite(RADIO_RELAY_PIN, HIGH);
digitalWrite(ACCESSORIES_RELAY_PIN, HIGH);
}
}

void logData() {
if (dataFileName == "") {
return; // No SD card or file error
}

File dataFile = SD.open(dataFileName, FILE_WRITE);

if (dataFile) {
DateTime now = rtc.now();

// Format timestamp
String timestamp = String(now.year()) + "/" +
String(now.month()) + "/" +
String(now.day()) + " " +
String(now.hour()) + ":" +
String(now.minute()) + ":" +
String(now.second());

// Write data
dataFile.print(timestamp);
dataFile.print(",");
dataFile.print(batteryVoltage, 3);
dataFile.print(",");
dataFile.print(headlightsCurrent, 3);
dataFile.print(",");
dataFile.print(hvacCurrent, 3);
dataFile.print(",");
dataFile.print(radioCurrent, 3);
dataFile.print(",");
 dataFile.print(accessoriesCurrent, 3);
dataFile.print(",");
dataFile.print(totalCurrent, 3);
dataFile.print(",");
dataFile.print(temperature, 2);
dataFile.print(",");
dataFile.print(humidity, 2);
dataFile.print(",");
dataFile.print(engineRunning ? "1" : "0");
dataFile.print(",");
dataFile.println((headlightsControlled || hvacControlled || radioControlled ||
accessoriesControlled) ? "1" : "0");

dataFile.close();
} else {
Serial.println("Error opening file for logging!");
}
}

void updateHistoricalData() {
// Get current hour
DateTime now = rtc.now();
int hour = now.hour();

// If hour has changed, update the historical data

if (hour != currentHour) {
// Update the historical data for the previous hour
if (loadHistoryCount < 24) {
loadHistoryCount++;
}

// Simple moving average

loadHistory[currentHour] = (loadHistory[currentHour] * 0.7) + (totalCurrent *
0.3);

// Update current hour

currentHour = hour;

// Save historical data to SD card

saveHistoricalData();
}
}

void loadHistoricalData() {
// Try to load historical data from SD card
if (SD.exists("history.json")) {
File historyFile = SD.open("history.json", FILE_READ);
if (historyFile) {
// Parse JSON
StaticJsonDocument<512> doc;
DeserializationError error = deserializeJson(doc, historyFile);
historyFile.close();
 if (!error) {
loadHistoryCount = doc["count"];
currentHour = doc["currentHour"];

JsonArray historyArray = doc["history"];

for (int i = 0; i < 24; i++) {
loadHistory[i] = historyArray[i];
}

Serial.println("Loaded historical data");

} else {
Serial.println("Failed to parse historical data");
}
}
}
}

void saveHistoricalData() {
// Save historical data to SD card
StaticJsonDocument<512> doc;

doc["count"] = loadHistoryCount;
doc["currentHour"] = currentHour;

JsonArray historyArray = doc.createNestedArray("history");

for (int i = 0; i < 24; i++) {
historyArray.add(loadHistory[i]);
}

File historyFile = SD.open("history.json", FILE_WRITE);

if (historyFile) {
serializeJson(doc, historyFile);
historyFile.close();
Serial.println("Saved historical data");
} else {
Serial.println("Failed to save historical data");
}
}

Installation in Vehicle

Prepare the Device

1. Assemble all components in a protective enclosure

2. Ensure all connections are secure and insulated
3. Label all wires for easy identification
Install in Vehicle

1. Disconnect the vehicle's battery negative terminal

2. Locate the electrical systems you want to monitor and control:
3. Headlights circuit
4. HVAC system
5. Radio/entertainment system
6. Accessory circuits
7. Install current sensors in series with each circuit:
8. Cut the positive wire at a convenient location
9. Connect one end to the current sensor input
10. Connect the other end to the current sensor output
11. Secure all connections with proper terminals and heat shrink
12. Install relay modules in series with non-essential systems:
13. Cut the positive wire at a convenient location
14. Connect the input side to the relay's COM terminal
15. Connect the output side to the relay's NC terminal
16. This configuration allows power to flow when the relay is not energized (fail-safe)
17. Connect the voltage divider to the battery:
18. Connect through an appropriate fuse (1A)
19. Ensure good connections to avoid false readings
20. Mount the enclosure in a protected location:
21. Away from extreme heat sources
22. Protected from water and debris
23. Accessible for maintenance
24. Reconnect the battery negative terminal

AI Enhancement

Data Collection and Analysis

1. Let the system run for at least a week to collect baseline data
2. Download the SD card and analyze the data using Python

Python Script for Data Analysis

Create a file named load_analysis.py with the following code:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import glob
import os

# Function to load and process CSV data

def load_data(file_path):
# Load the CSV file
df = pd.read_csv(file_path, parse_dates=[0])

# Set timestamp as index

df.set_index('Timestamp', inplace=True)

# Add hour of day column

df['HourOfDay'] = df.index.hour

return df

# Function to plot daily patterns

def plot_daily_patterns(df):
# Group by hour of day and calculate mean
hourly_avg = df.groupby('HourOfDay').mean()

# Create a figure with subplots

fig, axs = plt.subplots(2, 1, figsize=(12, 10))

# Plot total current by hour

axs[0].plot(hourly_avg.index, hourly_avg['TotalCurrent'], 'b-', linewidth=2)
axs[0].set_ylabel('Average Current (A)')
axs[0].set_title('Average Current by Hour of Day')
axs[0].grid(True)

# Plot battery voltage by hour

axs[1].plot(hourly_avg.index, hourly_avg['BatteryVoltage'], 'r-', linewidth=2)
axs[1].set_ylabel('Average Battery Voltage (V)')
axs[1].set_xlabel('Hour of Day')
axs[1].set_title('Average Battery Voltage by Hour of Day')
axs[1].grid(True)

plt.tight_layout()
plt.savefig('daily_patterns.png')
plt.close()

# Function to identify usage patterns using clustering

def identify_patterns(df):
# Select features for clustering
features = df[['HeadlightsCurrent', 'HVACCurrent', 'RadioCurrent',
'AccessoriesCurrent', 'Temperature', 'HourOfDay']]

# Standardize the features

scaler = StandardScaler()
scaled_features = scaler.fit_transform(features)
 # Determine optimal number of clusters using elbow method
inertia = []
k_range = range(1, 10)
for k in k_range:
kmeans = KMeans(n_clusters=k, random_state=42)
kmeans.fit(scaled_features)
inertia.append(kmeans.inertia_)

# Plot elbow curve

plt.figure(figsize=(8, 6))
plt.plot(k_range, inertia, 'bo-')
plt.xlabel('Number of Clusters')
plt.ylabel('Inertia')
plt.title('Elbow Method for Optimal k')
plt.grid(True)
plt.savefig('elbow_curve.png')
plt.close()

# Choose optimal k (this is a simple approach, you might want to refine it)
k_optimal = 4 # This should be determined from the elbow curve

# Perform clustering with optimal k

kmeans = KMeans(n_clusters=k_optimal, random_state=42)
df['Cluster'] = kmeans.fit_predict(scaled_features)

# Analyze clusters
cluster_analysis = df.groupby('Cluster').mean()

# Plot cluster characteristics

plt.figure(figsize=(12, 8))

# Create a bar chart for each cluster

bar_width = 0.15
index = np.arange(4) # Four current measurements

for i in range(k_optimal):
plt.bar(index + i*bar_width,
cluster_analysis.iloc[i][['HeadlightsCurrent', 'HVACCurrent', 'RadioCurrent',
'AccessoriesCurrent']],
bar_width,
label=f'Cluster {i}')

plt.xlabel('System')
plt.ylabel('Average Current (A)')
plt.title('Current Usage Patterns by Cluster')
plt.xticks(index + bar_width * (k_optimal-1)/2, ['Headlights', 'HVAC', 'Radio',
'Accessories'])
plt.legend()
plt.grid(True)
plt.savefig('cluster_analysis.png')
plt.close()
 return cluster_analysis

# Function to generate recommendations

def generate_recommendations(df, cluster_analysis):
# Calculate total energy consumption
df['Energy'] = df['TotalCurrent'] * df['BatteryVoltage'] / 60 # Wh per minute

# Calculate energy by system

df['HeadlightsEnergy'] = df['HeadlightsCurrent'] * df['BatteryVoltage'] / 60
df['HVACEnergy'] = df['HVACCurrent'] * df['BatteryVoltage'] / 60
df['RadioEnergy'] = df['RadioCurrent'] * df['BatteryVoltage'] / 60
df['AccessoriesEnergy'] = df['AccessoriesCurrent'] * df['BatteryVoltage'] / 60

# Calculate total energy by system

total_energy = df['Energy'].sum()
headlights_energy = df['HeadlightsEnergy'].sum()
hvac_energy = df['HVACEnergy'].sum()
radio_energy = df['RadioEnergy'].sum()
accessories_energy = df['AccessoriesEnergy'].sum()

# Calculate percentage of total energy

headlights_pct = headlights_energy / total_energy * 100
hvac_pct = hvac_energy / total_energy * 100
radio_pct = radio_energy / total_energy * 100
accessories_pct = accessories_energy / total_energy * 100

# Generate recommendations
recommendations = []

# Check for low voltage events

low_voltage_events = df[df['BatteryVoltage'] < 12.0]
if not low_voltage_events.empty:
recommendations.append("Low voltage events detected. Consider checking
battery health.")

# Check if low voltage correlates with specific systems

low_voltage_systems = low_voltage_events[['HeadlightsCurrent',
'HVACCurrent', 'RadioCurrent', 'AccessoriesCurrent']].mean()
high_current_system = low_voltage_systems.idxmax()

if high_current_system == 'HeadlightsCurrent' and

low_voltage_systems['HeadlightsCurrent'] > 5:

recommendations.append("Low voltage events correlate with high headlight

usage. Consider upgrading to LED headlights to reduce current draw.")
elif high_current_system == 'HVACCurrent' and
low_voltage_systems['HVACCurrent'] > 10:
recommendations.append("Low voltage events correlate with high HVAC
usage. Consider reducing HVAC usage when engine is off.")

# Check for high current events

 high_current_events = df[df['TotalCurrent'] > 50]
if not high_current_events.empty:
recommendations.append("High current events detected. Consider upgrading
alternator or battery if these occur frequently.")

# System-specific recommendations
if hvac_pct > 40:
recommendations.append("HVAC system accounts for a large percentage of
energy usage. Consider optimizing climate control settings.")

if accessories_pct > 30:

recommendations.append("Accessory circuits use a significant amount of
energy. Consider auditing these circuits for unnecessary loads.")

# Cluster-specific recommendations
for i, cluster in cluster_analysis.iterrows():
if cluster['EngineRunning'] < 0.5 and cluster['TotalCurrent'] > 20:
recommendations.append(f"Usage pattern {i} shows high current draw
({cluster['TotalCurrent']:.1f}A) with engine off. This may lead to battery drain.")

return recommendations

# Main function
def main():
# Find all CSV files
csv_files = glob.glob('*.csv')
if not csv_files:
print("No data files found!")
return

# Load and combine all data

all_data = pd.DataFrame()
for file in csv_files:
df = load_data(file)
all_data = pd.concat([all_data, df])

print(f"Loaded {len(all_data)} data points from {len(csv_files)} files")

# Plot daily patterns

plot_daily_patterns(all_data)

# Identify usage patterns

cluster_analysis = identify_patterns(all_data)
print("\nCluster Analysis:")
print(cluster_analysis)

# Generate recommendations
recommendations = generate_recommendations(all_data, cluster_analysis)

# Print and save recommendations

print("\nRecommendations:")
with open('recommendations.txt', 'w') as f:
 f.write("Smart Electrical Load Management System Recommendations\n")
f.write("===================================================\n\n")
for i, rec in enumerate(recommendations, 1):
print(f"{i}. {rec}")
f.write(f"{i}. {rec}\n")

if __name__ == "__main__":
main()

Enhanced Arduino Code with Machine Learning

After analyzing the data, you can enhance the Arduino code with a simple machine
learning model. Create a new file called load_management_ml.ino :

// Add these variables to the global variables section

#define NUM_FEATURES 6
#define NUM_CLUSTERS 4

// Cluster centroids (to be filled in after Python analysis)

float clusterCentroids[NUM_CLUSTERS][NUM_FEATURES] = {
{0.5, 12.0, 5.0, 0.2, 25.0, 12.0}, // Example values - replace with actual centroids
{8.0, 2.0, 0.5, 0.1, 20.0, 18.0},
{0.2, 0.5, 5.0, 2.0, 22.0, 8.0},
{5.0, 8.0, 2.0, 1.0, 18.0, 22.0}
};

// Cluster-specific thresholds
float clusterMaxCurrent[NUM_CLUSTERS] = {30.0, 40.0, 25.0, 35.0}; // Example
values

// Current usage pattern

int currentCluster = 0;

// Add this function to identify the current usage pattern

void identifyUsagePattern() {
// Create feature vector
float features[NUM_FEATURES] = {
headlightsCurrent,
hvacCurrent,
radioCurrent,
accessoriesCurrent,
temperature,
float(rtc.now().hour())
};

// Find closest cluster (simple K-means prediction)

float minDistance = 1e9;
for (int i = 0; i < NUM_CLUSTERS; i++) {
float distance = 0;
 for (int j = 0; j < NUM_FEATURES; j++) {
float diff = features[j] - clusterCentroids[i][j];
distance += diff * diff;
}

if (distance < minDistance) {

minDistance = distance;
currentCluster = i;
}
}

// Print current cluster for debugging

Serial.print("Current usage pattern: Cluster ");
Serial.println(currentCluster);
}

// Modify the manageLoads function to use cluster-specific thresholds

void manageLoads() {
// Identify current usage pattern
identifyUsagePattern();

// Reset control flags

bool needToManageLoads = false;
headlightsControlled = false;
hvacControlled = false;
radioControlled = false;
accessoriesControlled = false;

// Check if load management is needed

if (!engineRunning && batteryVoltage < LOW_VOLTAGE_THRESHOLD) {
needToManageLoads = true;
} else if (totalCurrent > clusterMaxCurrent[currentCluster]) {
// Use cluster-specific threshold
needToManageLoads = true;
} else if (predictedLoad > clusterMaxCurrent[currentCluster] && totalCurrent >
0.7 * clusterMaxCurrent[currentCluster]) {
// If we predict we'll exceed max current soon and we're already at 70% capacity
needToManageLoads = true;
}

// Rest of the function remains the same...

}

Testing and Calibration

Initial Testing

1. Before installing in the vehicle, test the system on a bench:

2. Connect a 12V power supply
 3. Simulate loads using resistors or small 12V devices
4. Verify that all sensors are reading correctly
5. Test the relay control functionality

Calibration

1. Calibrate the current sensors:

2. For each sensor, measure the actual current using a multimeter in series
3. Adjust the CURRENT_SENSOR_SENSITIVITY and CURRENT_SENSOR_OFFSET
values in the code

4. Repeat until readings match the multimeter

5. Calibrate the voltage sensor:

6. Measure the actual battery voltage using a multimeter

7. Adjust the VOLTAGE_DIVIDER_RATIO value in the code
8. Repeat until readings match the multimeter

In-Vehicle Testing

1. After installation, monitor the system for several days:

2. Check that all readings are reasonable
3. Verify that the load management activates appropriately

4. Ensure that critical systems are never disabled

5. Fine-tune thresholds:

6. Adjust LOW_VOLTAGE_THRESHOLD based on your battery's characteristics

7. Adjust MAX_TOTAL_CURRENT based on your vehicle's electrical system capacity
8. Adjust system priorities based on your preferences

Advanced Features

Remote Monitoring

1. Add a Bluetooth or WiFi module to enable remote monitoring:

2. For Bluetooth: HC-05 or HC-06 module

3. For WiFi: ESP8266 or ESP32 (if not already using ESP32 as main controller)

4. Create a simple mobile app using MIT App Inventor or similar platform:
 5. Display current readings
6. Show historical data
7. Provide alerts for low battery or high current conditions

Predictive Maintenance

1. Enhance the AI model to detect battery degradation:

2. Monitor voltage recovery after starting
3. Track voltage drop under load over time

4. Alert when battery performance decreases significantly

5. Implement alternator health monitoring:

6. Compare charging voltage to expected values

7. Monitor for voltage instability
8. Alert when alternator performance decreases

Voice Alerts

1. Add a small speaker and audio module:

2. DFPlayer Mini or similar
3. Pre-record alert messages
4. Provide voice alerts for critical conditions

Troubleshooting

Common Issues

1. Inaccurate Current Readings

2. Ensure the current sensor is properly calibrated
3. Check that the sensor is correctly oriented in the circuit
4. Verify the CURRENT_SENSOR_SENSITIVITY value matches your sensor model

5. Try taking multiple readings and averaging them

6. Inaccurate Voltage Readings

7. Measure the actual resistor values and update the VOLTAGE_DIVIDER_RATIO

8. Check for loose connections in the voltage divider circuit

9. Verify ground connections are solid

10. Relay Chattering

 11. Add hysteresis to the control logic to prevent rapid on/off cycling
12. Ensure relay coils have flyback diodes to prevent voltage spikes

13. Add capacitors to filter noise on sensor readings

14. System Not Powering Up

15. Verify the voltage regulator is working correctly

16. Check all power connections

17. Ensure the vehicle's electrical system is providing adequate voltage

18. SD Card Errors

19. Format the SD card as FAT32

20. Try a different SD card
21. Check the connections between the SD card module and Arduino/ESP32

Future Enhancements
1. Add GPS tracking to correlate electrical usage with driving routes
2. Implement more sophisticated machine learning models using TensorFlow Lite
3. Create a web dashboard for long-term data analysis
4. Add support for CAN bus integration to access vehicle ECU data
5. Implement predictive models for battery life estimation
6. Add solar charging capability for extended parking periods

Resources
• Arduino Documentation
• ESP32 Documentation
• ACS712 Current Sensor Datasheet
• Scikit-learn Documentation
• Battery University for understanding battery behavior
• Automotive Electrical Systems Handbook