feat: implement dust sensor (SDS011 - UART interface)

lib/communication/science_lab.dart

@@ -1392,4 +1392,48 @@ class ScienceLab {
       logger.e("Error in servo4(): $e");
     }
   }
+
+  Future<void> configureUART({required int baudRate}) async {
+    if (!isConnected()) return;
+
+    try {
+      mPacketHandler.sendByte(mCommandsProto.uart2);
+      mPacketHandler.sendByte(mCommandsProto.setBaud);
+      mPacketHandler.sendInt(baudRate);
+
+      await mPacketHandler.getAcknowledgement();
+      logger.i("UART2 peripheral successfully configured at $baudRate baud.");
+    } catch (e) {
+      logger.e("Error configuring UART2: $e");
+      rethrow;
+    }
+  }
+
+  Future<int> getUART2BytesAvailable() async {
+    if (!isConnected()) return 0;
+    try {
+      mPacketHandler.sendByte(mCommandsProto.uart2);
+      mPacketHandler.sendByte(mCommandsProto.readUart2Status);
+      return await mPacketHandler.getByte();
+    } catch (e) {
+      logger.e("Error reading UART2 status: $e");
+      return 0;
+    }
+  }
+
+  Future<List<int>> readUARTBytes(int bytesToRead) async {
+    if (!isConnected()) return [];
+
+    try {
+      mPacketHandler.sendByte(mCommandsProto.uart2);
+      mPacketHandler.sendByte(mCommandsProto.readByte);
+      mPacketHandler.sendByte(bytesToRead);
+      Uint8List rawBuffer = Uint8List(bytesToRead + 1); // +1 for ACK
+      await mPacketHandler.read(rawBuffer, bytesToRead + 1);
+      return rawBuffer.sublist(0, bytesToRead).map((b) => b & 0xFF).toList();
+    } catch (e) {
+      logger.e("Error reading bytes from UART2: $e");
+      return [];
+    }
+  }
 }

lib/l10n/app_en.arb

@@ -347,6 +347,7 @@
     "manualMode": "Manual Mode",
     "frequencyChange": "Stop playback to change frequency.",
     "playBackStop": "Playback stopped",
+    "dustSensorIntro": "Connect pins according to pin diagram and start measuring. Power up the sensor using VCC pin in PSLab and connect data pin to CH1. Make sure the ground wire is connected to one of the GND pins in PSLab.",
     "soundMeterIntro": "Sound meter Introduction",
     "soundMeterDescFull": "To measure the loudness in the environment in decibel(dB)",
     "luxMeterDescFull": "The Lux meter can be used to measure the ambient light intensity. This instruments is compatible with either the built-in light sensor on any Android device or the BH-1750 light sensor.",
@@ -695,6 +696,15 @@
     "comingSoon": "Coming Soon",
     "startRecording": "Start Recording",
     "stopRecording": "Stop Recording",
+    "ppm": "PPM",
+    "airQuality": "Air Quality",
+    "good": "Good",
+    "moderate": "Moderate",
+    "unhealthy": "Unhealthy",
+    "hazardous": "Hazardous",
+    "dustSensorConfig": "Dust Sensor Configurations",
+    "dustUpdatePeriodHint": "Please provide time interval at which data will be updated (100 ms to 1000 ms)",
+    "dustHighLimitHint": "Please provide the maximum limit of PPM value to be recorded (0.0 PPM to 5.0 PPM)",
     "gasSensorGuideIntro": "To use this instrument, you need an MQ-135 semiconductor gas sensor.",
     "gasSensorGuideDetail": "The MQ-135 is primarily intended for detecting flammable gases and broad air quality, but its readings can be mathematically translated to estimate CO2 Parts Per Million (PPM).",
     "gasSensorGuideConnectLabel": "How to connect:",

lib/main.dart

@@ -16,6 +16,7 @@ import 'package:pslab/providers/settings_config_provider.dart';
 import 'package:pslab/view/accelerometer_screen.dart';
 import 'package:pslab/view/barometer_screen.dart';
 import 'package:pslab/view/connect_device_screen.dart';
+import 'package:pslab/view/dust_sensor_screen.dart';
 import 'package:pslab/view/faq_screen.dart';
 import 'package:pslab/view/gas_sensor_screen.dart';
 import 'package:pslab/view/gyroscope_screen.dart';
@@ -118,6 +119,8 @@ class MyApp extends StatelessWidget {
                     const _LocaleAware(child: LogicAnalyzerScreen()),
                 '/powerSource': (context) =>
                     const _LocaleAware(child: PowerSourceScreen()),
+                '/dustsensor': (context) =>
+                    const _LocaleAware(child: DustSensorScreen()),
                 '/compass': (context) =>
                     const _LocaleAware(child: CompassScreen()),
                 '/connectDevice': (context) =>

lib/models/dust_sensor_config.dart

@@ -0,0 +1,45 @@
+class DustSensorConfig {
+  final int updatePeriod;
+  final double highLimit;
+  final String activeSensor;
+  final bool includeLocationData;
+
+  const DustSensorConfig({
+    this.updatePeriod = 1000,
+    this.highLimit = 4.0,
+    this.activeSensor = 'In-built Sensor',
+    this.includeLocationData = true,
+  });
+
+  DustSensorConfig copyWith({
+    int? updatePeriod,
+    double? highLimit,
+    String? activeSensor,
+    bool? includeLocationData,
+  }) {
+    return DustSensorConfig(
+      updatePeriod: updatePeriod ?? this.updatePeriod,
+      highLimit: highLimit ?? this.highLimit,
+      activeSensor: activeSensor ?? this.activeSensor,
+      includeLocationData: includeLocationData ?? this.includeLocationData,
+    );
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      'updatePeriod': updatePeriod,
+      'highLimit': highLimit,
+      'activeSensor': activeSensor,
+      'includeLocationData': includeLocationData,
+    };
+  }
+
+  factory DustSensorConfig.fromJson(Map<String, dynamic> json) {
+    return DustSensorConfig(
+      updatePeriod: json['updatePeriod'] ?? 1000,
+      highLimit: (json['highLimit'] ?? 4.0).toDouble(),
+      activeSensor: json['activeSensor'] ?? 'In-built Sensor',
+      includeLocationData: json['includeLocationData'] ?? true,
+    );
+  }
+}

lib/providers/dust_sensor_config_provider.dart

@@ -0,0 +1,64 @@
+import 'package:flutter/foundation.dart';
+import 'dart:convert';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:pslab/models/dust_sensor_config.dart';
+
+class DustSensorConfigProvider extends ChangeNotifier {
+  DustSensorConfig _config = const DustSensorConfig();
+  DustSensorConfig get config => _config;
+
+  DustSensorConfigProvider() {
+    _loadConfigFromPrefs();
+  }
+
+  Future<void> _loadConfigFromPrefs() async {
+    final prefs = await SharedPreferences.getInstance();
+    final jsonString = prefs.getString('dust_config');
+    if (jsonString != null) {
+      final Map<String, dynamic> jsonMap = json.decode(jsonString);
+      _config = DustSensorConfig.fromJson(jsonMap);
+      notifyListeners();
+    }
+  }
+
+  Future<void> _saveConfigToPrefs() async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString('dust_config', json.encode(_config.toJson()));
+  }
+
+  void updateConfig(DustSensorConfig newConfig) {
+    _config = newConfig;
+    notifyListeners();
+    _saveConfigToPrefs();
+  }
+
+  void updateUpdatePeriod(int updatePeriod) {
+    _config = _config.copyWith(updatePeriod: updatePeriod);
+    notifyListeners();
+    _saveConfigToPrefs();
+  }
+
+  void updateHighLimit(double highLimit) {
+    _config = _config.copyWith(highLimit: highLimit);
+    notifyListeners();
+    _saveConfigToPrefs();
+  }
+
+  void updateActiveSensor(String activeSensor) {
+    _config = _config.copyWith(activeSensor: activeSensor);
+    notifyListeners();
+    _saveConfigToPrefs();
+  }
+
+  void updateIncludeLocationData(bool includeLocationData) {
+    _config = _config.copyWith(includeLocationData: includeLocationData);
+    notifyListeners();
+    _saveConfigToPrefs();
+  }
+
+  void resetToDefaults() {
+    _config = const DustSensorConfig();
+    notifyListeners();
+    _saveConfigToPrefs();
+  }
+}