Energy Consumption Monitoring Mobile App Development

Developing Mobile Applications for Energy Consumption Monitoring

An electricity meter that connects via Modbus RTU delivers raw registers: voltage, current, active and reactive power, accumulated energy in kWh. Converting this into an understandable dashboard is the mobile application's task. But before the dashboard comes a more important task: how to obtain and deliver this data to the phone in the first place.

Meter Protocols and Gateways

Industrial meters (Mercury 230, AGAT, Eastron SDM630) communicate via Modbus RTU over RS-485. Smart meters for residential use (Sagemcom, Itron) use DLMS/COSEM, M-Bus, or P1-port (Dutch Smart Meter). New commercial meters with GPRS/NB-IoT modules have cloud APIs from manufacturers.

For Modbus meters, you need an RS-485 → Ethernet gateway (Moxa NPort, Anybus X-gateway) or an IoT gateway with Modbus agent. Mobile applications always work with a backend or MQTT broker — never directly with the meter.

For P1-port (Netherlands, Belgium), there are P1-to-MQTT adapters — small ESP32/Raspberry Pi devices that parse DSMR telegrams and publish to MQTT.

Data Processing: Aggregation and Storage

The meter delivers instantaneous values. Applications need trends over hours, days, months — this requires aggregation and storage. On the backend, use InfluxDB or TimescaleDB (PostgreSQL extension). TimescaleDB suits small installations: SQL queries, time_bucket function:

SELECT
  time_bucket('1 hour', time) AS hour,
  device_id,
  MAX(active_energy_kwh) - MIN(active_energy_kwh) AS consumption_kwh,
  AVG(active_power_w) AS avg_power_w
FROM energy_readings
WHERE device_id = $1
  AND time BETWEEN $2 AND $3
GROUP BY 1, 2
ORDER BY 1;

The difference between MAX and MIN accumulated energy over a period equals consumption during that period. A simple and reliable formula that requires no delta calculations.

Mobile Application: Real-Time Dashboard

Using Flutter with BLoC:

class EnergyDashboardBloc extends Bloc<EnergyEvent, EnergyDashboardState> {
  final EnergyRepository _repo;
  StreamSubscription? _realtimeSub;

  EnergyDashboardBloc(this._repo) : super(EnergyDashboardInitial()) {
    on<LoadDashboard>((event, emit) async {
      emit(EnergyDashboardLoading());
      try {
        final current = await _repo.getCurrentReadings(event.meterId);
        final todayChart = await _repo.getHourlyConsumption(
          event.meterId,
          DateTime.now().subtract(const Duration(hours: 24)),
          DateTime.now(),
        );
        emit(EnergyDashboardLoaded(current: current, hourlyChart: todayChart));
        _startRealtimeUpdates(event.meterId);
      } catch (e) {
        emit(EnergyDashboardError(message: e.toString()));
      }
    });

    on<RealtimeUpdated>((event, emit) {
      if (state is EnergyDashboardLoaded) {
        emit((state as EnergyDashboardLoaded).copyWith(current: event.reading));
      }
    });
  }

  void _startRealtimeUpdates(String meterId) {
    _realtimeSub = _repo.realtimeStream(meterId)
        .listen((reading) => add(RealtimeUpdated(reading)));
  }
}

Dashboard cards display: active power (kW), voltage per phase (for three-phase meters — three values), power factor (cosφ), consumption for the current day, consumption for the month vs previous month.

Consumption Graph

fl_chart with BarChart for hourly consumption is standard in energy applications. Color coding by tariff zones (night tariff — blue, daytime — orange):

BarChartGroupData buildHourBarGroup(int hour, double consumption) {
  final isNightTariff = hour < 7 || hour >= 23;
  return BarChartGroupData(
    x: hour,
    barRods: [
      BarChartRodData(
        toY: consumption,
        color: isNightTariff ? Colors.blue.shade300 : Colors.orange.shade400,
        width: 12,
        borderRadius: const BorderRadius.vertical(top: Radius.circular(4)),
      ),
    ],
  );
}

Alerts Based on Thresholds

Monitoring contracted power exceedance is one of the key features for commercial facilities. Power limit violations lead to penalties from energy suppliers. The backend checks a rolling 15-minute maximum; mobile applications receive alerts via FCM/APNs.

For Android, send push notifications with PRIORITY_HIGH via FCM Data Message (not Notification Message) — delivered even in Doze mode. FCM Data Message is processed in FirebaseMessagingService.onMessageReceived() and displayed as a local notification with custom sound.

Multi-Property Monitoring

For property management companies monitoring 50-100 facilities — a list of properties with color status indicators (normal/exceeded/no data), sorted by consumption. Lazy loading via ListView.builder with pagination of 20 items.

Developing an application for monitoring one meter with a dashboard and historical data: 3-4 weeks. Multi-property monitoring with load management and alerts: 2-3 months. Cost is calculated after analyzing equipment and requirements.