Introduction

Java SE Embedded is a specialized Java runtime optimized for ARM-based embedded devices with constrained resources. This comprehensive guide covers development, deployment, and optimization for ARM embedded systems.

Project Setup and Configuration

Maven Dependencies for Cross-Compilation

<!-- pom.xml --> <properties> <java.version>11</java.version> <maven.compiler.source>11</maven.compiler.source> <maven.compiler.target>11</maven.compiler.target> <pi4j.version>2.3.0</pi4j.version> <logback.version>1.4.11</logback.version> </properties> <dependencies> <!-- Pi4J for GPIO access (Raspberry Pi) --> <dependency> <groupId>com.pi4j</groupId> <artifactId>pi4j-core</artifactId> <version>${pi4j.version}</version> </dependency> <dependency> <groupId>com.pi4j</groupId> <artifactId>pi4j-plugin-raspberrypi</artifactId> <version>${pi4j.version}</version> </dependency> <dependency> <groupId>com.pi4j</groupId> <artifactId>pi4j-plugin-pigpio</artifactId> <version>${pi4j.version}</version> </dependency> <!-- Logging --> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>${logback.version}</version> </dependency> <!-- JSON Processing --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.15.2</version> </dependency> <!-- HTTP Client --> <dependency> <groupId>org.apache.httpcomponents.client5</groupId> <artifactId>httpclient5</artifactId> <version>5.2.1</version> </dependency> <!-- Embedded Database --> <dependency> <groupId>org.xerial</groupId> <artifactId>sqlite-jdbc</artifactId> <version>3.42.0.0</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.11.0</version> <configuration> <source>11</source> <target>11</target> <compilerArgs> <arg>-Xlint:unchecked</arg> <arg>-Xlint:deprecation</arg> </compilerArgs> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>3.4.1</version> <executions> <execution> <phase>package</phase> <goals> <goal>shade</goal> </goals> <configuration> <transformers> <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> <mainClass>com.embedded.MainApplication</mainClass> </transformer> </transformers> <filters> <filter> <artifact>*:*</artifact> <excludes> <exclude>META-INF/*.SF</exclude> <exclude>META-INF/*.DSA</exclude> <exclude>META-INF/*.RSA</exclude> </excludes> </filter> </filters> </configuration> </execution> </executions> </plugin> </plugins> </build>

Core Embedded Framework

System Monitor and Resource Management

package com.embedded.core; import java.lang.management.*; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class SystemMonitor { private final ScheduledExecutorService scheduler; private final AtomicBoolean isMonitoring; private final Runtime runtime; private final OperatingSystemMXBean osBean; private final MemoryMXBean memoryBean; // Resource thresholds (adjust based on your device) private static final double MEMORY_THRESHOLD = 0.85; // 85% private static final double CPU_THRESHOLD = 0.80; // 80% private static final long DISK_THRESHOLD = 50 * 1024 * 1024; // 50MB public SystemMonitor() { this.scheduler = Executors.newScheduledThreadPool(1); this.isMonitoring = new AtomicBoolean(false); this.runtime = Runtime.getRuntime(); this.osBean = ManagementFactory.getOperatingSystemMXBean(); this.memoryBean = ManagementFactory.getMemoryMXBean(); } public void startMonitoring() { if (isMonitoring.compareAndSet(false, true)) { scheduler.scheduleAtFixedRate(this::monitorSystem, 0, 5, TimeUnit.SECONDS); SystemLogger.info("System monitoring started"); } } public void stopMonitoring() { if (isMonitoring.compareAndSet(true, false)) { scheduler.shutdown(); SystemLogger.info("System monitoring stopped"); } } private void monitorSystem() { try { SystemMetrics metrics = collectMetrics(); checkThresholds(metrics); logMetrics(metrics); } catch (Exception e) { SystemLogger.error("Error monitoring system: " + e.getMessage()); } } private SystemMetrics collectMetrics() { SystemMetrics metrics = new SystemMetrics(); // Memory metrics long totalMemory = runtime.totalMemory(); long freeMemory = runtime.freeMemory(); long usedMemory = totalMemory - freeMemory; long maxMemory = runtime.maxMemory(); metrics.setMemoryUsed(usedMemory); metrics.setMemoryTotal(totalMemory); metrics.setMemoryMax(maxMemory); metrics.setMemoryUsage((double) usedMemory / totalMemory); // CPU metrics (approximation) if (osBean instanceof com.sun.management.OperatingSystemMXBean) { com.sun.management.OperatingSystemMXBean sunOsBean = (com.sun.management.OperatingSystemMXBean) osBean; metrics.setCpuLoad(sunOsBean.getSystemCpuLoad()); metrics.setProcessCpuLoad(sunOsBean.getProcessCpuLoad()); } // Thread metrics ThreadMXBean threadBean = ManagementFactory.getThreadMXBean(); metrics.setThreadCount(threadBean.getThreadCount()); metrics.setDaemonThreadCount(threadBean.getDaemonThreadCount()); // GC metrics for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) { metrics.addGcCollectionCount(gc.getCollectionCount()); metrics.addGcCollectionTime(gc.getCollectionTime()); } return metrics; } private void checkThresholds(SystemMetrics metrics) { // Memory threshold check if (metrics.getMemoryUsage() > MEMORY_THRESHOLD) { SystemLogger.warn("High memory usage: " + String.format("%.2f%%", metrics.getMemoryUsage() * 100)); triggerMemoryCleanup(); } // CPU threshold check if (metrics.getCpuLoad() > CPU_THRESHOLD) { SystemLogger.warn("High CPU usage: " + String.format("%.2f%%", metrics.getCpuLoad() * 100)); } // Thread count monitoring if (metrics.getThreadCount() > 100) { SystemLogger.warn("High thread count: " + metrics.getThreadCount()); } } private void triggerMemoryCleanup() { SystemLogger.info("Initiating memory cleanup"); System.gc(); // Suggest garbage collection // Additional cleanup actions MemoryManager.getInstance().cleanupCaches(); } private void logMetrics(SystemMetrics metrics) { if (SystemLogger.isDebugEnabled()) { SystemLogger.debug(String.format( "Memory: %d/%d MB (%.1f%%) | Threads: %d | CPU: %.1f%%", metrics.getMemoryUsed() / (1024 * 1024), metrics.getMemoryTotal() / (1024 * 1024), metrics.getMemoryUsage() * 100, metrics.getThreadCount(), metrics.getCpuLoad() * 100 )); } } public static class SystemMetrics { private long memoryUsed; private long memoryTotal; private long memoryMax; private double memoryUsage; private double cpuLoad; private double processCpuLoad; private int threadCount; private int daemonThreadCount; private long gcCollectionCount; private long gcCollectionTime; // Getters and setters public long getMemoryUsed() { return memoryUsed; } public void setMemoryUsed(long memoryUsed) { this.memoryUsed = memoryUsed; } public long getMemoryTotal() { return memoryTotal; } public void setMemoryTotal(long memoryTotal) { this.memoryTotal = memoryTotal; } public long getMemoryMax() { return memoryMax; } public void setMemoryMax(long memoryMax) { this.memoryMax = memoryMax; } public double getMemoryUsage() { return memoryUsage; } public void setMemoryUsage(double memoryUsage) { this.memoryUsage = memoryUsage; } public double getCpuLoad() { return cpuLoad; } public void setCpuLoad(double cpuLoad) { this.cpuLoad = cpuLoad; } public double getProcessCpuLoad() { return processCpuLoad; } public void setProcessCpuLoad(double processCpuLoad) { this.processCpuLoad = processCpuLoad; } public int getThreadCount() { return threadCount; } public void setThreadCount(int threadCount) { this.threadCount = threadCount; } public int getDaemonThreadCount() { return daemonThreadCount; } public void setDaemonThreadCount(int daemonThreadCount) { this.daemonThreadCount = daemonThreadCount; } public long getGcCollectionCount() { return gcCollectionCount; } public void addGcCollectionCount(long count) { this.gcCollectionCount += count; } public long getGcCollectionTime() { return gcCollectionTime; } public void addGcCollectionTime(long time) { this.gcCollectionTime += time; } } }

GPIO Management for Raspberry Pi

package com.embedded.gpio; import com.pi4j.Pi4J; import com.pi4j.context.Context; import com.pi4j.io.gpio.digital.*; import com.pi4j.io.i2c.I2C; import com.pi4j.io.i2c.I2CConfig; import com.pi4j.io.i2c.I2CProvider; import com.pi4j.io.spi.Spi; import com.pi4j.io.spi.SpiConfig; import com.pi4j.io.spi.SpiProvider; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class GPIOManager { private final Context pi4j; private final Map<String, DigitalOutput> outputPins; private final Map<String, DigitalInput> inputPins; private final ScheduledExecutorService scheduler; private final SystemLogger logger; // Common pin configurations private static final DigitalState LED_ON = DigitalState.HIGH; private static final DigitalState LED_OFF = DigitalState.LOW; public GPIOManager() { this.pi4j = Pi4J.newAutoContext(); this.outputPins = new ConcurrentHashMap<>(); this.inputPins = new ConcurrentHashMap<>(); this.scheduler = Executors.newScheduledThreadPool(2); this.logger = SystemLogger.getInstance(); initializeDefaultPins(); } private void initializeDefaultPins() { // Initialize common pins for embedded projects setupOutputPin("LED_STATUS", 17); // Status LED setupOutputPin("RELAY_1", 18); // Relay control setupInputPin("BUTTON_1", 27); // Button input setupInputPin("SENSOR_1", 22); // Sensor input logger.info("GPIO Manager initialized with default pins"); } public void setupOutputPin(String name, int address) { try { DigitalOutputConfig config = DigitalOutput.newConfigBuilder(pi4j) .id(name) .name(name) .address(address) .provider("pigpio-digital-output") .initial(DigitalState.LOW) .shutdown(DigitalState.LOW) .build(); DigitalOutput output = pi4j.create(config); outputPins.put(name, output); logger.info("Output pin configured: " + name + " on GPIO " + address); } catch (Exception e) { logger.error("Failed to setup output pin " + name + ": " + e.getMessage()); } } public void setupInputPin(String name, int address) { try { DigitalInputConfig config = DigitalInput.newConfigBuilder(pi4j) .id(name) .name(name) .address(address) .provider("pigpio-digital-input") .pull(PullResistance.PULL_UP) .debounce(3000L) // 3ms debounce .build(); DigitalInput input = pi4j.create(config); inputPins.put(name, input); // Add listener for input changes input.addListener(event -> { handleInputChange(name, event.state()); }); logger.info("Input pin configured: " + name + " on GPIO " + address); } catch (Exception e) { logger.error("Failed to setup input pin " + name + ": " + e.getMessage()); } } private void handleInputChange(String pinName, DigitalState state) { logger.debug("Input " + pinName + " changed to: " + state); // Handle specific input events switch (pinName) { case "BUTTON_1": handleButtonPress(state); break; case "SENSOR_1": handleSensorTrigger(state); break; } } private void handleButtonPress(DigitalState state) { if (state == DigitalState.LOW) { // Assuming pull-up resistor logger.info("Button pressed"); // Toggle status LED on button press togglePin("LED_STATUS"); } } private void handleSensorTrigger(DigitalState state) { if (state == DigitalState.HIGH) { logger.info("Sensor triggered"); // Add sensor-specific logic here } } public void setPinState(String pinName, DigitalState state) { DigitalOutput output = outputPins.get(pinName); if (output != null) { output.state(state); logger.debug("Set " + pinName + " to: " + state); } else { logger.warn("Output pin not found: " + pinName); } } public void togglePin(String pinName) { DigitalOutput output = outputPins.get(pinName); if (output != null) { DigitalState current = output.state(); DigitalState newState = (current == DigitalState.HIGH) ? DigitalState.LOW : DigitalState.HIGH; output.state(newState); logger.debug("Toggled " + pinName + " to: " + newState); } } public DigitalState getInputState(String pinName) { DigitalInput input = inputPins.get(pinName); return (input != null) ? input.state() : DigitalState.UNKNOWN; } public void blinkPin(String pinName, long durationMs, int count) { scheduler.submit(() -> { try { for (int i = 0; i < count; i++) { setPinState(pinName, LED_ON); Thread.sleep(durationMs); setPinState(pinName, LED_OFF); if (i < count - 1) { Thread.sleep(durationMs); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); logger.warn("Blink operation interrupted for pin: " + pinName); } }); } public void setupPWMPin(String pinName, int address) { try { // Pi4J v2.0+ PWM support // Note: Actual implementation depends on Pi4J version and platform logger.info("PWM pin configured: " + pinName + " on GPIO " + address); } catch (Exception e) { logger.error("Failed to setup PWM pin " + pinName + ": " + e.getMessage()); } } public I2C setupI2CDevice(int bus, int deviceAddress) { try { I2CProvider i2CProvider = pi4j.provider("pigpio-i2c"); I2CConfig i2cConfig = I2C.newConfigBuilder(pi4j) .id("I2C-" + deviceAddress) .bus(bus) .device(deviceAddress) .build(); return i2CProvider.create(i2cConfig); } catch (Exception e) { logger.error("Failed to setup I2C device: " + e.getMessage()); return null; } } public void shutdown() { // Turn off all outputs for (DigitalOutput output : outputPins.values()) { output.state(DigitalState.LOW); } scheduler.shutdown(); try { if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) { scheduler.shutdownNow(); } } catch (InterruptedException e) { scheduler.shutdownNow(); Thread.currentThread().interrupt(); } pi4j.shutdown(); logger.info("GPIO Manager shutdown completed"); } }

Embedded Sensor Framework

Sensor Manager

package com.embedded.sensors; import com.embedded.core.SystemLogger; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.core.type.TypeReference; import java.io.File; import java.io.IOException; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class SensorManager { private final Map<String, Sensor> sensors; private final ScheduledExecutorService scheduler; private final ObjectMapper objectMapper; private final SystemLogger logger; private final String configFile; private volatile boolean isRunning = false; public SensorManager(String configFile) { this.sensors = new ConcurrentHashMap<>(); this.scheduler = Executors.newScheduledThreadPool(3); this.objectMapper = new ObjectMapper(); this.logger = SystemLogger.getInstance(); this.configFile = configFile; loadSensorConfig(); } private void loadSensorConfig() { try { File config = new File(configFile); if (config.exists()) { List<SensorConfig> configs = objectMapper.readValue( config, new TypeReference<List<SensorConfig>>() {}); for (SensorConfig sensorConfig : configs) { registerSensor(createSensorFromConfig(sensorConfig)); } logger.info("Loaded " + sensors.size() + " sensors from config"); } else { logger.warn("Sensor config file not found: " + configFile); setupDefaultSensors(); } } catch (IOException e) { logger.error("Failed to load sensor config: " + e.getMessage()); setupDefaultSensors(); } } private void setupDefaultSensors() { // Register default sensors for common embedded scenarios registerSensor(new TemperatureSensor("TEMP_1", 1000)); registerSensor(new HumiditySensor("HUMIDITY_1", 2000)); registerSensor(new MotionSensor("MOTION_1", 500)); logger.info("Default sensors configured"); } private Sensor createSensorFromConfig(SensorConfig config) { switch (config.getType()) { case "temperature": return new TemperatureSensor(config.getId(), config.getInterval()); case "humidity": return new HumiditySensor(config.getId(), config.getInterval()); case "motion": return new MotionSensor(config.getId(), config.getInterval()); case "light": return new LightSensor(config.getId(), config.getInterval()); default: logger.warn("Unknown sensor type: " + config.getType()); return new DummySensor(config.getId(), config.getInterval()); } } public void registerSensor(Sensor sensor) { sensors.put(sensor.getId(), sensor); logger.info("Registered sensor: " + sensor.getId()); } public void unregisterSensor(String sensorId) { Sensor sensor = sensors.remove(sensorId); if (sensor != null) { sensor.stop(); logger.info("Unregistered sensor: " + sensorId); } } public void startMonitoring() { if (isRunning) return; isRunning = true; for (Sensor sensor : sensors.values()) { startSensorMonitoring(sensor); } logger.info("Sensor monitoring started"); } public void stopMonitoring() { if (!isRunning) return; isRunning = false; for (Sensor sensor : sensors.values()) { sensor.stop(); } scheduler.shutdown(); logger.info("Sensor monitoring stopped"); } private void startSensorMonitoring(Sensor sensor) { scheduler.scheduleAtFixedRate(() -> { try { SensorReading reading = sensor.read(); if (reading != null) { processSensorReading(reading); } } catch (Exception e) { logger.error("Error reading sensor " + sensor.getId() + ": " + e.getMessage()); } }, 0, sensor.getInterval(), TimeUnit.MILLISECONDS); } private void processSensorReading(SensorReading reading) { // Log the reading logger.debug(String.format("Sensor %s: %.2f %s", reading.getSensorId(), reading.getValue(), reading.getUnit())); // Check thresholds and trigger alerts checkThresholds(reading); // Store reading in database SensorDataStore.getInstance().storeReading(reading); // Notify listeners SensorEvent event = new SensorEvent(reading); SensorEventBus.getInstance().publish(event); } private void checkThresholds(SensorReading reading) { Sensor sensor = sensors.get(reading.getSensorId()); if (sensor != null && sensor.hasThresholds()) { SensorThresholds thresholds = sensor.getThresholds(); if (reading.getValue() > thresholds.getMaxValue()) { triggerAlert(reading, "MAX_THRESHOLD_EXCEEDED"); } else if (reading.getValue() < thresholds.getMinValue()) { triggerAlert(reading, "MIN_THRESHOLD_EXCEEDED"); } } } private void triggerAlert(SensorReading reading, String alertType) { SensorAlert alert = new SensorAlert( reading.getSensorId(), alertType, reading.getValue(), System.currentTimeMillis(), "Threshold violation detected" ); logger.warn("Sensor alert: " + alert); // Send alert via available channels AlertManager.getInstance().sendAlert(alert); } public SensorReading getLatestReading(String sensorId) { Sensor sensor = sensors.get(sensorId); return (sensor != null) ? sensor.getLastReading() : null; } public Map<String, SensorReading> getAllLatestReadings() { Map<String, SensorReading> readings = new HashMap<>(); for (Sensor sensor : sensors.values()) { readings.put(sensor.getId(), sensor.getLastReading()); } return readings; } public void calibrateSensor(String sensorId) { Sensor sensor = sensors.get(sensorId); if (sensor != null && sensor instanceof Calibratable) { ((Calibratable) sensor).calibrate(); logger.info("Calibrated sensor: " + sensorId); } else { logger.warn("Sensor does not support calibration: " + sensorId); } } } // Sensor base classes and interfaces abstract class Sensor { protected final String id; protected final long interval; protected volatile SensorReading lastReading; protected volatile boolean running = false; public Sensor(String id, long interval) { this.id = id; this.interval = interval; } public abstract SensorReading read(); public abstract String getUnit(); public abstract SensorType getType(); public void stop() { running = false; } // Getters public String getId() { return id; } public long getInterval() { return interval; } public SensorReading getLastReading() { return lastReading; } public boolean hasThresholds() { return false; } public SensorThresholds getThresholds() { return null; } } class SensorReading { private final String sensorId; private final double value; private final String unit; private final long timestamp; private final Map<String, Object> metadata; public SensorReading(String sensorId, double value, String unit) { this.sensorId = sensorId; this.value = value; this.unit = unit; this.timestamp = System.currentTimeMillis(); this.metadata = new HashMap<>(); } // Getters and setters public String getSensorId() { return sensorId; } public double getValue() { return value; } public String getUnit() { return unit; } public long getTimestamp() { return timestamp; } public Map<String, Object> getMetadata() { return metadata; } public void addMetadata(String key, Object value) { metadata.put(key, value); } } interface Calibratable { void calibrate(); } enum SensorType { TEMPERATURE, HUMIDITY, PRESSURE, MOTION, LIGHT, PROXIMITY, OTHER } // Example sensor implementations class TemperatureSensor extends Sensor { private static final Random random = new Random(); public TemperatureSensor(String id, long interval) { super(id, interval); } @Override public SensorReading read() { // Simulate temperature reading (replace with actual sensor code) double temperature = 20.0 + (random.nextDouble() * 10.0); // 20-30°C SensorReading reading = new SensorReading(id, temperature, "°C"); lastReading = reading; return reading; } @Override public String getUnit() { return "°C"; } @Override public SensorType getType() { return SensorType.TEMPERATURE; } } class HumiditySensor extends Sensor { private static final Random random = new Random(); public HumiditySensor(String id, long interval) { super(id, interval); } @Override public SensorReading read() { // Simulate humidity reading double humidity = 40.0 + (random.nextDouble() * 30.0); // 40-70% SensorReading reading = new SensorReading(id, humidity, "%"); lastReading = reading; return reading; } @Override public String getUnit() { return "%"; } @Override public SensorType getType() { return SensorType.HUMIDITY; } } class MotionSensor extends Sensor { private static final Random random = new Random(); private int motionCount = 0; public MotionSensor(String id, long interval) { super(id, interval); } @Override public SensorReading read() { // Simulate motion detection (10% chance) boolean motionDetected = random.nextDouble() < 0.1; if (motionDetected) { motionCount++; } SensorReading reading = new SensorReading(id, motionDetected ? 1 : 0, "bool"); reading.addMetadata("motionCount", motionCount); lastReading = reading; return reading; } @Override public String getUnit() { return "bool"; } @Override public SensorType getType() { return SensorType.MOTION; } } // Configuration classes class SensorConfig { private String id; private String type; private long interval; private Map<String, Object> parameters; // Getters and setters public String getId() { return id; } public void setId(String id) { this.id = id; } public String getType() { return type; } public void setType(String type) { this.type = type; } public long getInterval() { return interval; } public void setInterval(long interval) { this.interval = interval; } public Map<String, Object> getParameters() { return parameters; } public void setParameters(Map<String, Object> parameters) { this.parameters = parameters; } } class SensorThresholds { private double minValue; private double maxValue; private String unit; // Getters and setters public double getMinValue() { return minValue; } public void setMinValue(double minValue) { this.minValue = minValue; } public double getMaxValue() { return maxValue; } public void setMaxValue(double maxValue) { this.maxValue = maxValue; } public String getUnit() { return unit; } public void setUnit(String unit) { this.unit = unit; } }

Power Management

package com.embedded.power; import com.embedded.core.SystemLogger; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; public class PowerManager { private final ScheduledExecutorService scheduler; private final AtomicBoolean isMonitoring; private final SystemLogger logger; // Power states private volatile PowerState currentState = PowerState.NORMAL; private volatile double batteryLevel = 100.0; private volatile boolean isCharging = false; // Power thresholds private static final double LOW_BATTERY_THRESHOLD = 20.0; private static final double CRITICAL_BATTERY_THRESHOLD = 10.0; public PowerManager() { this.scheduler = Executors.newScheduledThreadPool(1); this.isMonitoring = new AtomicBoolean(false); this.logger = SystemLogger.getInstance(); } public void startPowerMonitoring() { if (isMonitoring.compareAndSet(false, true)) { scheduler.scheduleAtFixedRate(this::monitorPower, 0, 30, TimeUnit.SECONDS); logger.info("Power monitoring started"); } } public void stopPowerMonitoring() { if (isMonitoring.compareAndSet(true, false)) { scheduler.shutdown(); logger.info("Power monitoring stopped"); } } private void monitorPower() { try { updateBatteryInfo(); checkPowerState(); logPowerStatus(); } catch (Exception e) { logger.error("Error monitoring power: " + e.getMessage()); } } private void updateBatteryInfo() { // Read battery information from system // This is platform-specific - here's an example for Linux try { // Read from /sys/class/power_supply (Linux) batteryLevel = readBatteryLevel(); isCharging = readChargingStatus(); } catch (Exception e) { // Fallback to simulated values for development batteryLevel = Math.max(0, batteryLevel - 0.1); isCharging = batteryLevel < 95.0; } } private double readBatteryLevel() throws IOException { // Linux battery level reading example try (BufferedReader reader = new BufferedReader( new FileReader("/sys/class/power_supply/BAT0/capacity"))) { return Double.parseDouble(reader.readLine().trim()); } catch (Exception e) { throw new IOException("Cannot read battery level", e); } } private boolean readChargingStatus() throws IOException { // Linux charging status reading example try (BufferedReader reader = new BufferedReader( new FileReader("/sys/class/power_supply/BAT0/status"))) { String status = reader.readLine().trim(); return "Charging".equalsIgnoreCase(status); } catch (Exception e) { throw new IOException("Cannot read charging status", e); } } private void checkPowerState() { PowerState newState = determinePowerState(); if (newState != currentState) { PowerState oldState = currentState; currentState = newState; handlePowerStateTransition(oldState, newState); } } private PowerState determinePowerState() { if (batteryLevel <= CRITICAL_BATTERY_THRESHOLD) { return PowerState.CRITICAL; } else if (batteryLevel <= LOW_BATTERY_THRESHOLD) { return PowerState.LOW; } else if (isCharging) { return PowerState.CHARGING; } else { return PowerState.NORMAL; } } private void handlePowerStateTransition(PowerState oldState, PowerState newState) { logger.info(String.format("Power state changed: %s -> %s (Battery: %.1f%%)", oldState, newState, batteryLevel)); switch (newState) { case LOW: enablePowerSavingMode(); break; case CRITICAL: enableCriticalPowerMode(); break; case CHARGING: disablePowerSavingMode(); break; } } private void enablePowerSavingMode() { logger.warn("Enabling power saving mode"); // Reduce CPU frequency executeCommand("sudo cpufreq-set -g powersave"); // Reduce screen brightness executeCommand("echo 50 | sudo tee /sys/class/backlight/*/brightness"); // Disable non-essential services ServiceManager.getInstance().stopNonEssentialServices(); } private void enableCriticalPowerMode() { logger.error("Enabling critical power mode - preparing for shutdown"); // Further reduce power consumption executeCommand("sudo cpufreq-set -g powersave"); executeCommand("echo 10 | sudo tee /sys/class/backlight/*/brightness"); // Stop all non-critical services ServiceManager.getInstance().stopAllButCriticalServices(); // Schedule shutdown if not charging if (!isCharging) { scheduler.schedule(this::initiateShutdown, 2, TimeUnit.MINUTES); } } private void disablePowerSavingMode() { logger.info("Disabling power saving mode"); // Restore normal CPU frequency executeCommand("sudo cpufreq-set -g ondemand"); // Restore screen brightness executeCommand("echo 100 | sudo tee /sys/class/backlight/*/brightness"); // Restart services ServiceManager.getInstance().restartStoppedServices(); } private void initiateShutdown() { if (!isCharging && batteryLevel <= 5.0) { logger.error("Initiating emergency shutdown - battery critically low"); executeCommand("sudo shutdown -h now"); } } private void executeCommand(String command) { try { Runtime.getRuntime().exec(command); } catch (IOException e) { logger.error("Failed to execute command: " + command + " - " + e.getMessage()); } } private void logPowerStatus() { if (logger.isDebugEnabled()) { logger.debug(String.format( "Battery: %.1f%% | Charging: %s | State: %s", batteryLevel, isCharging, currentState )); } } public double getBatteryLevel() { return batteryLevel; } public boolean isCharging() { return isCharging; } public PowerState getPowerState() { return currentState; } public enum PowerState { NORMAL, LOW, CRITICAL, CHARGING } }

Main Application

```java
package com.embedded