鸿蒙太阳能路灯控制系统开发指南 原创

鸿蒙太阳能路灯控制系统开发指南

一、系统架构设计

基于HarmonyOS的太阳能路灯控制系统采用四层架构：
感知层：光照传感器、时钟模块、电池状态监测

控制层：LED驱动、充放电管理

通信层：设备组网与远程控制

能源层：太阳能电池与锂电池管理

!https://example.com/harmony-solar-light-arch.png

二、核心代码实现
光控+时控双模式切换

// LightControl.ets
import sensor from ‘@ohos.sensor’;
import timer from ‘@ohos.timer’;
import powerManagement from ‘@ohos.powerManagement’;

class LightController {
private static instance: LightController = null;
private currentMode: ‘LIGHT’ | ‘TIME’ = ‘LIGHT’;
private isLightOn: boolean = false;
private brightness: number = 0;
private powerManager: powerManagement.PowerManager;

// 时间控制配置
private timeSchedule = {
winter: { on: 18, off: 6 }, // 冬季18点开，6点关
summer: { on: 19, off: 5 } // 夏季19点开，5点关
};

constructor() {
this.powerManager = powerManagement.createPowerManager();
this.initSensors();
this.initTimer();
public static getInstance(): LightController {

if (!LightController.instance) {
  LightController.instance = new LightController();

return LightController.instance;

private initSensors(): void {

// 光照传感器监听
sensor.on('light', (data) => {
  this.handleLightChange(data.value);
});

// 电池状态监听
powerManagement.on('batteryLevelChange', (level) => {
  this.adjustByBattery(level);
});

private initTimer(): void {

// 每分钟检查一次时间模式
timer.setInterval(() => {
  this.checkTimeMode();
}, 60000);

// 光照变化处理

private handleLightChange(lux: number): void {
if (this.currentMode === ‘LIGHT’) {
const targetState = lux < 10; // 10lux以下开灯

  if (targetState !== this.isLightOn) {
    this.toggleLight(targetState);

// 在光照模式下仍根据时间微调亮度

  this.adjustByTime();

}

// 时间模式检查
private checkTimeMode(): void {
const now = new Date();
const hours = now.getHours();
const isWinter = now.getMonth() >= 10 || now.getMonth() <= 2;
const schedule = isWinter ? this.timeSchedule.winter : this.timeSchedule.summer;

const shouldBeOn = hours >= schedule.on || hours < schedule.off;

if (this.currentMode === 'TIME') {
  if (shouldBeOn !== this.isLightOn) {
    this.toggleLight(shouldBeOn);

}

// 自动模式切换逻辑
const batteryLevel = powerManagement.getBatteryLevel();
if (batteryLevel < 30) {
  this.currentMode = 'LIGHT'; // 低电量时强制使用光控

else {

  // 根据季节和时间自动切换模式
  const currentHour = now.getHours();
  if (currentHour >= 8 && currentHour <= 18) {
    this.currentMode = 'LIGHT';

else {

    this.currentMode = 'TIME';

}

// 开关灯控制

private toggleLight(on: boolean): void {
this.isLightOn = on;

if (on) {
  this.startFadeIn();

else {

  this.startFadeOut();

EventBus.emit(‘lightStateChange’, on);

// 根据电池状态调整亮度

private adjustByBattery(batteryLevel: number): void {
if (batteryLevel < 20) {
this.setMaxBrightness(50); // 电量低于20%时最大亮度限制为50%
else if (batteryLevel < 50) {

  this.setMaxBrightness(80);

else {

  this.setMaxBrightness(100);

}

// 根据时间调整亮度
private adjustByTime(): void {
const now = new Date();
const hours = now.getHours();

if (hours >= 0 && hours < 5) {
  // 深夜时段降低亮度
  this.setTargetBrightness(30);

else if (hours >= 22 || hours < 6) {

  // 夜间时段中等亮度
  this.setTargetBrightness(70);

else {

  // 傍晚时段全亮度
  this.setTargetBrightness(100);

}

// 设置最大亮度限制
private setMaxBrightness(max: number): void {
if (this.brightness > max) {
this.setBrightness(max);
}

// 设置目标亮度
private setTargetBrightness(target: number): void {
if (Math.abs(this.brightness - target) > 5) {
this.fadeTo(target);
}

// 渐变到指定亮度
private fadeTo(target: number): void {
const step = target > this.brightness ? 1 : -1;
const interval = setInterval(() => {
this.brightness += step;
this.updateLED();

  if (this.brightness === target) {
    clearInterval(interval);

}, 30); // 30ms步进

// 淡入效果

private startFadeIn(): void {
this.brightness = 0;
this.fadeTo(100);
// 淡出效果

private startFadeOut(): void {
this.fadeTo(0);
// 更新LED实际亮度

private updateLED(): void {
// 调用PWM驱动设置亮度
ledDriver.setBrightness(this.brightness);
}

export const lightController = LightController.getInstance();

电池充放电管理

// BatteryManager.ets
import powerManagement from ‘@ohos.powerManagement’;
import driver from ‘@ohos.driver’;

class BatteryManager {
private static instance: BatteryManager = null;
private chargeController: driver.I2C;
private currentStatus = {
level: 100,
isCharging: false,
voltage: 3.7,
current: 0
};

// 电池保护参数
private readonly MAX_CHARGE_VOLTAGE = 4.2;
private readonly MIN_DISCHARGE_VOLTAGE = 3.0;
private readonly MAX_CHARGE_CURRENT = 2.0; // 2A

constructor() {
this.initChargeController();
this.startMonitoring();
public static getInstance(): BatteryManager {

if (!BatteryManager.instance) {
  BatteryManager.instance = new BatteryManager();

return BatteryManager.instance;

private initChargeController(): void {

try {
  this.chargeController = driver.createI2C({
    bus: 'I2C_1',
    address: 0x34
  });
  
  // 初始化充电芯片
  this.writeRegister(0x00, 0x01); // 启用充电
  this.writeRegister(0x01, 0x1A); // 设置充电电流2A

catch (err) {

  console.error('充电控制器初始化失败:', JSON.stringify(err));

}

private startMonitoring(): void {
// 每10秒读取一次电池状态
timer.setInterval(() => {
this.readBatteryStatus();
}, 10000);

// 监听系统电池事件
powerManagement.on('batteryLevelChange', (level) => {
  this.currentStatus.level = level;
  this.adjustCharge();
});

private readBatteryStatus(): void {

try {
  const voltage = this.readRegister(0x02) / 1000; // mV转V
  const current = this.readRegister(0x03) / 1000; // mA转A
  const status = this.readRegister(0x04);
  
  this.currentStatus = {
    level: powerManagement.getBatteryLevel(),
    isCharging: (status & 0x01) === 0x01,
    voltage,
    current
  };
  
  this.checkSafety();
  this.adjustCharge();
  
  // 同步状态到其他设备
  this.syncStatus();

catch (err) {

  console.error('读取电池状态失败:', JSON.stringify(err));

}

// 安全检查
private checkSafety(): void {
if (this.currentStatus.voltage > this.MAX_CHARGE_VOLTAGE) {
this.stopCharging();
console.error(‘电池过压保护触发’);
if (this.currentStatus.voltage < this.MIN_DISCHARGE_VOLTAGE) {

  this.enterLowPowerMode();
  console.error('电池欠压保护触发');

if (Math.abs(this.currentStatus.current) > this.MAX_CHARGE_CURRENT) {

  this.limitCurrent();
  console.error('过流保护触发');

}

// 调整充电策略
private adjustCharge(): void {
const solarVoltage = this.readSolarInput();

if (solarVoltage > 5) { // 有太阳能输入
  if (this.currentStatus.level < 95) {
    this.startCharging();

else {

    this.switchToTrickleCharge();

} else {

  this.stopCharging();

// 根据电量调整路灯亮度

if (this.currentStatus.level < 30) {
  lightController.setMaxBrightness(50);

else if (this.currentStatus.level < 50) {

  lightController.setMaxBrightness(80);

}

// 读取太阳能输入电压
private readSolarInput(): number {
try {
return this.readRegister(0x05) / 1000; // mV转V
catch (err) {

  console.error('读取太阳能输入失败:', JSON.stringify(err));
  return 0;

}

// 开始充电
private startCharging(): void {
this.writeRegister(0x00, 0x01);
// 停止充电

private stopCharging(): void {
this.writeRegister(0x00, 0x00);
// 切换至涓流充电

private switchToTrickleCharge(): void {
this.writeRegister(0x01, 0x0A); // 设置充电电流0.5A
// 限流保护

private limitCurrent(): void {
this.writeRegister(0x01, 0x0A); // 临时降低充电电流
// 低电量模式

private enterLowPowerMode(): void {
lightController.setMaxBrightness(30);
this.stopCharging();
// 同步状态到其他设备

private syncStatus(): void {
distributedData.syncData(‘battery_status’, {
type: ‘battery_update’,
data: this.currentStatus
});
private writeRegister(reg: number, value: number): void {

this.chargeController.write([reg, value]);

private readRegister(reg: number): number {

this.chargeController.write([reg]);
const result = this.chargeController.read(2);
return (result[0] << 8) | result[1];

}

export const batteryManager = BatteryManager.getInstance();

亮度渐变算法

// LEDDriver.ets
import driver from ‘@ohos.driver’;
import pwm from ‘@ohos.pwm’;

class LEDDriver {
private static instance: LEDDriver = null;
private pwmController: pwm.PWM;
private currentBrightness: number = 0;
private fadeInterval: number | null = null;

constructor() {
this.initPWM();
public static getInstance(): LEDDriver {

if (!LEDDriver.instance) {
  LEDDriver.instance = new LEDDriver();

return LEDDriver.instance;

private initPWM(): void {

try {
  this.pwmController = pwm.createPWM({
    bus: 'PWM_0',
    period: 10000, // 10kHz
    duty: 0
  });
  
  this.pwmController.enable();

catch (err) {

  console.error('PWM初始化失败:', JSON.stringify(err));

}

// 设置亮度（0-100）
public setBrightness(level: number): void {
level = Math.max(0, Math.min(100, level));
this.currentBrightness = level;

// 非线性亮度映射（人眼对低亮度更敏感）
const duty = this.mapBrightness(level);
this.pwmController.setDuty(duty);

// 非线性亮度映射

private mapBrightness(level: number): number {
// Gamma校正（γ=2.8）
const gamma = 2.8;
const normalized = level / 100;
const corrected = Math.pow(normalized, gamma);
return corrected * this.pwmController.getPeriod();
// 渐变到指定亮度

public fadeTo(target: number, duration: number = 1000): void {
if (this.fadeInterval) {
clearInterval(this.fadeInterval);
target = Math.max(0, Math.min(100, target));

const steps = duration / 30; // 每30ms一步
const stepSize = (target - this.currentBrightness) / steps;
let stepCount = 0;

this.fadeInterval = setInterval(() => {
  this.currentBrightness += stepSize;
  this.setBrightness(this.currentBrightness);
  
  stepCount++;
  if (stepCount >= steps) {
    this.setBrightness(target);
    if (this.fadeInterval) {
      clearInterval(this.fadeInterval);
      this.fadeInterval = null;

}

}, 30);

// 淡入效果

public fadeIn(duration: number = 1000): void {
this.fadeTo(100, duration);
// 淡出效果

public fadeOut(duration: number = 1000): void {
this.fadeTo(0, duration);
}

export const ledDriver = LEDDriver.getInstance();

跨设备组网与同步

// NetworkManager.ets
import distributedData from ‘@ohos.distributedData’;
import bluetooth from ‘@ohos.bluetooth’;

class LightNetwork {
private static instance: LightNetwork = null;
private dataManager: distributedData.DataManager;
private groupId: string = ‘’;
private nodes: Array<string> = [];

constructor() {
this.dataManager = distributedData.createDataManager({
bundleName: ‘com.example.solarlight’,
area: distributedData.Area.GLOBAL
});

this.initListeners();

public static getInstance(): LightNetwork {

if (!LightNetwork.instance) {
  LightNetwork.instance = new LightNetwork();

return LightNetwork.instance;

private initListeners(): void {

// 监听组网请求
this.dataManager.registerDataListener('light_network', (data) => {
  if (data?.type === 'join_request') {
    this.handleJoinRequest(data.deviceId);

else if (data?.type === ‘state_update’) {

    this.handleStateUpdate(data.payload);

});

// 蓝牙设备发现
bluetooth.on('deviceFound', (devices) => {
  const lights = devices.filter(d => d.deviceName.startsWith('SolarLight'));
  this.nodes = lights.map(d => d.deviceId);
});

// 创建或加入网络

public async joinNetwork(groupId: string): Promise<boolean> {
this.groupId = groupId;

try {
  await this.dataManager.syncData('light_network', {
    type: 'join_request',
    deviceId: deviceInfo.deviceId,
    groupId
  });
  
  return true;

catch (err) {

  console.error('加入网络失败:', JSON.stringify(err));
  return false;

}

// 处理加入请求
private handleJoinRequest(deviceId: string): void {
if (this.isGroupLeader()) {
this.nodes.push(deviceId);

  // 同步当前状态给新设备
  this.syncCurrentState();

}

// 同步状态到组内所有设备
public syncCurrentState(): void {
const state = {
brightness: ledDriver.getCurrentBrightness(),
mode: lightController.getCurrentMode(),
timestamp: Date.now()
};

this.dataManager.syncData('light_network', {
  type: 'state_update',
  payload: state
});

// 处理状态更新

private handleStateUpdate(state: any): void {
// 冲突解决：选择时间戳最新的状态
if (state.timestamp > this.lastUpdateTime) {
ledDriver.setBrightness(state.brightness);
lightController.setMode(state.mode);
this.lastUpdateTime = state.timestamp;
}

// 判断当前设备是否为组主
private isGroupLeader(): boolean {
if (this.nodes.length === 0) return false;

// 选择设备ID最小的作为组主
const sorted = [...this.nodes].sort();
return sorted[0] === deviceInfo.deviceId;

// 获取组内节点数量

public getNodeCount(): number {
return this.nodes.length;
}

export const lightNetwork = LightNetwork.getInstance();

主界面实现

// MainScreen.ets
import { lightController } from ‘./LightControl’;
import { batteryManager } from ‘./BatteryManager’;
import { ledDriver } from ‘./LEDDriver’;
import { lightNetwork } from ‘./NetworkManager’;

@Component
export struct MainScreen {
@State brightness: number = 0;
@State isLightOn: boolean = false;
@State batteryLevel: number = 100;
@State isCharging: boolean = false;
@State mode: string = ‘自动’;
@State nodeCount: number = 0;

build() {
Column() {
// 状态显示
Row() {
Text(this.isLightOn ? ‘路灯开启’ : ‘路灯关闭’)
.fontColor(this.isLightOn ? ‘#4CAF50’ : ‘#F44336’)

    Text(模式: ${this.mode})
      .margin({ left: 20 })

.padding(10)

  // 亮度控制
  Slider({
    value: this.brightness,
    min: 0,
    max: 100,
    onChange: (value) => {
      ledDriver.setBrightness(value);

})

  .width('80%')
  
  // 电池状态
  Row() {
    Text(电量: ${this.batteryLevel}%)
    Text(this.isCharging ? '充电中' : '放电中')
      .margin({ left: 20 })
      .fontColor(this.isCharging ? '#4CAF50' : '#FFC107')

.margin({ top: 20 })

  // 网络状态
  Text(组网设备: ${this.nodeCount}个)
    .margin({ top: 10 })
  
  // 控制按钮
  Row() {
    Button('开灯')
      .onClick(() => {
        lightController.turnOn();
      })
      .width(100)
    
    Button('关灯')
      .onClick(() => {
        lightController.turnOff();
      })
      .width(100)
      .margin({ left: 20 })

.margin({ top: 30 })

  // 模式切换
  Row() {
    Button('光控模式')
      .onClick(() => {
        lightController.setMode('LIGHT');
      })
      .width(120)
    
    Button('时控模式')
      .onClick(() => {
        lightController.setMode('TIME');
      })
      .width(120)
      .margin({ left: 20 })

.margin({ top: 20 })

.width(‘100%’)

.height('100%')
.padding(20)

aboutToAppear() {

// 监听路灯状态
EventBus.on('lightStateChange', (isOn: boolean) => {
  this.isLightOn = isOn;
});

// 监听亮度变化
EventBus.on('brightnessChange', (level: number) => {
  this.brightness = level;
});

// 监听电池状态
EventBus.on('batteryUpdate', (status: any) => {
  this.batteryLevel = status.level;
  this.isCharging = status.isCharging;
});

// 监听模式变化
EventBus.on('modeChange', (mode: string) => {
  this.mode = mode === 'LIGHT' ? '光控' : '时控';
});

// 监听网络变化
EventBus.on('networkUpdate', (count: number) => {
  this.nodeCount = count;
});

// 加入默认网络
lightNetwork.joinNetwork('solar_light_group');

aboutToDisappear() {

EventBus.off('lightStateChange');
EventBus.off('brightnessChange');
EventBus.off('batteryUpdate');
EventBus.off('modeChange');
EventBus.off('networkUpdate');

}

三、项目配置与权限

// module.json5
“module”: {

"requestPermissions": [

“name”: “ohos.permission.USE_LIGHT_SENSOR”,

    "reason": "读取环境光照强度"
  },

“name”: “ohos.permission.DISTRIBUTED_DATASYNC”,

    "reason": "同步路灯状态到其他设备"
  },

“name”: “ohos.permission.USE_BLUETOOTH”,

    "reason": "设备组网发现"
  },

“name”: “ohos.permission.MANAGE_POWER”,

    "reason": "电池充放电管理"
  },

“name”: “ohos.permission.USE_DRIVER_PWM”,

    "reason": "LED亮度控制"

],

"abilities": [

“name”: “MainAbility”,

    "type": "page",
    "backgroundModes": ["continuousTask", "bluetoothInteraction"],
    "visible": true

]

}

四、总结与扩展

本太阳能路灯控制系统实现了三大核心技术：
双模式智能切换：光控与时控无缝切换

高效能源管理：太阳能充电与锂电池保护

平滑亮度调节：符合人眼感知的渐变算法

扩展方向：
智能调光：根据人车流量自动调节亮度

故障预警：提前检测LED或电池异常

远程管理：通过手机APP控制路灯组

节能策略：根据天气预报调整充电策略

环境监测：集成空气质量检测功能

数据统计：记录能耗数据生成报告

通过HarmonyOS的分布式能力，该系统可以实现路灯之间的智能组网，形成自治的照明网络，大幅降低维护成本并提高能源利用效率。