ex1 and 5 working with sdk v10.0.0

lewispg228 · lewispg228 · commit c6aad08ba64a · 2024-11-25T16:25:20.000-07:00
-added in functionality to read PM 1
-added in functionality to get or set the measurement algorithm
diff --git a/examples/Example_01_BasicReadings/Example_01_BasicReadings.ino b/examples/Example_01_BasicReadings/Example_01_BasicReadings.ino
@@ -75,8 +75,11 @@ void loop()
     if (bmv080.dataAvailable())
     {
         float pm25 = bmv080.getPM25();
+        float pm1 = bmv080.getPM1();
 
         Serial.print(pm25);
+        Serial.print("\t");
+        Serial.print(pm1);
 
         if (bmv080.getIsObstructed() == true)
         {
diff --git a/examples/Example_05_Parameters/Example_05_Parameters.ino b/examples/Example_05_Parameters/Example_05_Parameters.ino
@@ -9,6 +9,7 @@
     distribution_id
     do_obstruction_detection
     do_vibration_filtering
+    measurement_algorithm
 
   After these parameters are read and set, This example shows how to use the 
   sensor in "continuous mode" to get particulate matter readings once every 
@@ -108,6 +109,7 @@ void getSetParameters(void)
     uint32_t distribution_id = 0;
     bool do_obstruction_detection = false;
     bool do_vibration_filtering = false;
+    uint8_t measurementAlgorithm = E_BMV080_MEASUREMENT_ALGORITHM_BALANCED;
 
     /***************************************************************************
      * 
@@ -155,6 +157,25 @@ void getSetParameters(void)
         Serial.println("false");
     }
 
+    /* Get default parameter "measurement_algorithm" */
+    measurementAlgorithm = bmv080.getMeasurementAlgorithm();
+    Serial.print("BMV080 parameter 'measurement_algorithm' READ: ");
+    switch (measurementAlgorithm)
+    {
+        case E_BMV080_MEASUREMENT_ALGORITHM_FAST_RESPONSE:
+            Serial.println("Fast Response");
+            break;
+        case E_BMV080_MEASUREMENT_ALGORITHM_BALANCED:
+            Serial.println("Balanced");
+            break;
+        case E_BMV080_MEASUREMENT_ALGORITHM_HIGH_PRECISION:
+            Serial.println("High Precision");
+            break;
+        default:
+            Serial.println("Unknown");
+            break;
+    }
+
 
     /***************************************************************************
      * 
@@ -169,6 +190,7 @@ void getSetParameters(void)
     // distribution_id = 3;
     // do_obstruction_detection = true;
     // do_vibration_filtering = false;
+    // measurementAlgorithm = E_BMV080_MEASUREMENT_ALGORITHM_BALANCED;
 
     /* Set custom parameter "volumetric_mass_density" */
     if(bmv080.setVolumetricMassDensity(volumetric_mass_density) == true)
@@ -239,5 +261,30 @@ void getSetParameters(void)
         Serial.println("Error setting BMV080 parameter 'do_vibration_filtering'");
     }
 
+    /* Set custom parameter "measurement_algorithm" */
+    if(bmv080.setMeasurementAlgorithm(measurementAlgorithm) == true)
+    {
+        Serial.print("BMV080 parameter 'measurement_algorithm' SET TO: ");
+        switch (measurementAlgorithm)
+        {
+            case E_BMV080_MEASUREMENT_ALGORITHM_FAST_RESPONSE:
+                Serial.println("Fast Response");
+                break;
+            case E_BMV080_MEASUREMENT_ALGORITHM_BALANCED:
+                Serial.println("Balanced");
+                break;
+            case E_BMV080_MEASUREMENT_ALGORITHM_HIGH_PRECISION:
+                Serial.println("High Precision");
+                break;
+            default:
+                Serial.println("Unknown");
+                break;
+        }
+    }
+    else
+    {
+        Serial.println("Error setting BMV080 parameter 'measurement_algorithm'");
+    }
+
     Serial.println();
 }
diff --git a/src/bmv080.h b/src/bmv080.h
@@ -151,6 +151,10 @@ bmv080_status_code_t bmv080_reset(const bmv080_handle_t handle);
 * <tr> <td> "distribution_id"               <td> uint32_t             <td>           <td> 3                          <td> For internal use only.
 * <tr> <td> "do_obstruction_detection"      <td> bool                 <td>           <td> true                       <td> Set if obstruction detection feature is enabled.
 * <tr> <td> "do_vibration_filtering"        <td> bool                 <td>           <td> false                      <td> Set if vibration filter is enabled.
+* <tr> <td> "measurement_algorithm"         <td> bmv080_measurement_algorithm_t <td> <td> E_BMV080_MEASUREMENT_ALGORITHM_HIGH_PRECISION (3) <td> Selection of measurement algorithm based on the
+*                                                                                                                    <br> use case, as defined by the type bmv080_measurement_algorithm_t,
+*                                                                                                                    <br> in bmv080_defs.h. For a duty cycling measurement, this parameter is
+*                                                                                                                    <br> fixed to E_BMV080_MEASUREMENT_ALGORITHM_FAST_RESPONSE.
 * </table>
 *
 * @pre A valid _handle_ generated by _bmv080_open_ is required.
@@ -192,7 +196,11 @@ bmv080_status_code_t bmv080_get_parameter(const bmv080_handle_t handle, const ch
 * <tr> <td> "distribution_id"               <td> uint32_t             <td>           <td> 3                          <td> For internal use only.
 * <tr> <td> "do_obstruction_detection"      <td> bool                 <td>           <td> true                       <td> Set if obstruction detection feature is enabled.
 * <tr> <td> "do_vibration_filtering"        <td> bool                 <td>           <td> false                      <td> Set if vibration filter is enabled.
-* </table>s
+* <tr> <td> "measurement_algorithm"         <td> bmv080_measurement_algorithm_t <td> <td> E_BMV080_MEASUREMENT_ALGORITHM_HIGH_PRECISION (3) <td> Selection of measurement algorithm based on the 
+*                                                                                                                    <br> use case, as defined by the type bmv080_measurement_algorithm_t,
+*                                                                                                                    <br> in bmv080_defs.h. For a duty cycling measurement, this parameter is
+*                                                                                                                    <br> fixed to E_BMV080_MEASUREMENT_ALGORITHM_FAST_RESPONSE.
+* </table>
 *
 * @pre A valid _handle_ generated by _bmv080_open_ is required.
 * @pre This function must be called before _bmv080_start_continuous_measurement_ or _bmv080_start_duty_cycling_measurement_
diff --git a/src/bmv080_defs.h b/src/bmv080_defs.h
@@ -364,6 +364,16 @@ typedef enum
     E_BMV080_DUTY_CYCLING_MODE_0 = 0
 } bmv080_duty_cycling_mode_t;
 
+/*!
+* @brief Measurement algorithm choices.
+*/
+typedef enum
+{
+    E_BMV080_MEASUREMENT_ALGORITHM_FAST_RESPONSE = 1,
+    E_BMV080_MEASUREMENT_ALGORITHM_BALANCED = 2,
+    E_BMV080_MEASUREMENT_ALGORITHM_HIGH_PRECISION = 3
+} bmv080_measurement_algorithm_t;
+
 /*!
 * @brief Placeholder structure for extended sensor output information.
 */
@@ -374,27 +384,36 @@ struct bmv080_extended_info_s;
 */
 typedef struct
 {
+    /*! runtime_in_sec: estimate of the time passed since the start of the measurement, in seconds */
+    float runtime_in_sec;
+    /*! pm2_5_mass_concentration: PM2.5 value in ug/m3 */
+    float pm2_5_mass_concentration;
+    /*! pm1_mass_concentration: PM1 value in ug/m3 */
+    float pm1_mass_concentration;
+    /*! is_obstructed: flag to indicate whether the sensor is obstructed and cannot perform a valid measurement */
+    bool is_obstructed;
+    /*! is_outside_measurement_range: flag to indicate whether the PM2.5 concentration is 
+     * outside the specified measurement range (0..1000 ug/m3) 
+     */
+    bool is_outside_measurement_range;
     /*! reserved_0: for internal use only */
     float reserved_0;
     /*! reserved_1: for internal use only */
     float reserved_1;
     /*! reserved_2: for internal use only */
     float reserved_2;
-    /*! pm2_5: PM2.5 value in ug/m3 */
-    float pm2_5;
-    /*! runtime_in_sec: estimate of the time passed since the start of the measurement, in seconds */
-    float runtime_in_sec;
-    /*! is_obstructed: flag to indicate whether the sensor is obstructed and cannot perform a valid measurement */
-    bool is_obstructed;
-    /*! is_outside_detection_limits: flag to indicate whether the PM2.5 concentration is outside the detection limits 
-     *  and a valid measurement cannot be performed 
-     */
-    bool is_outside_detection_limits;
+    /*! reserved_3: for internal use only */
+    float reserved_3; 
+    /*! reserved_4: for internal use only */
+    float reserved_4; 
+    /*! reserved_5: for internal use only */
+    float reserved_5; 
+    /*! reserved_6: for internal use only */
+    float reserved_6;
     /*! extended_info: for internal use only */
     struct bmv080_extended_info_s *extended_info;
 }bmv080_output_t;
 
-
 /*********************************************************************************************************************
 * Callback definitions
 *********************************************************************************************************************/
@@ -464,8 +483,4 @@ typedef uint32_t(*bmv080_callback_tick_t)(void);
 */
 typedef void(*bmv080_callback_data_ready_t)(bmv080_output_t bmv080_output, void* callback_parameters);
 
-
-/* Function pointer to facilitate printing output / status information to the console */
-typedef int (*print_function_t)(const char *const _format, ...);
-
 #endif /* BMV080_DEFS_H_ */
diff --git a/src/esp32/libbmv080.a b/src/esp32/libbmv080.a
diff --git a/src/esp32/libpostProcessor.a b/src/esp32/libpostProcessor.a
diff --git a/src/sfeBmv080.cpp b/src/sfeBmv080.cpp
@@ -141,7 +141,12 @@ sfeTkError_t sfeBmv080::begin(sfeTkIBus *theBus)
 
 float sfeBmv080::getPM25()
 {
-    return _sensorValue.pm2_5;
+    return _sensorValue.pm2_5_mass_concentration;
+}
+
+float sfeBmv080::getPM1()
+{
+    return _sensorValue.pm1_mass_concentration;
 }
 
 bool sfeBmv080::getIsObstructed()
@@ -152,10 +157,11 @@ bool sfeBmv080::getIsObstructed()
 void sfeBmv080::setSensorValue(bmv080_output_t bmv080_output)
 {
     _dataAvailable = true;
-    _sensorValue.pm2_5 = bmv080_output.pm2_5;
+    _sensorValue.pm2_5_mass_concentration = bmv080_output.pm2_5_mass_concentration;
+    _sensorValue.pm1_mass_concentration = bmv080_output.pm1_mass_concentration;
     _sensorValue.runtime_in_sec = bmv080_output.runtime_in_sec;
     _sensorValue.is_obstructed = bmv080_output.is_obstructed;
-    _sensorValue.is_outside_detection_limits = bmv080_output.is_outside_detection_limits;
+    _sensorValue.is_outside_measurement_range = bmv080_output.is_outside_measurement_range;
 }
 
 bool sfeBmv080::setMode(uint8_t mode)
@@ -476,4 +482,36 @@ bool sfeBmv080::setDoVibrationFiltering(bool do_vibration_filtering)
     {
         return true;
     }
+}
+
+uint8_t sfeBmv080::getMeasurementAlgorithm()
+{
+    bmv080_measurement_algorithm_t measurement_algorithm;
+    bmv080_status_code_t bmv080_current_status =
+        bmv080_get_parameter(bmv080_handle_class, "measurement_algorithm", (void *)&measurement_algorithm);
+    if (bmv080_current_status != E_BMV080_OK)
+    {
+        printf("Error getting BMV080 Measurement Algorithm: %d\n", bmv080_current_status);
+        return 0;
+    }
+    else
+    {
+        return (uint8_t)measurement_algorithm;
+    }
+}
+
+bool sfeBmv080::setMeasurementAlgorithm(uint8_t measurement_algorithm)
+{
+    bmv080_measurement_algorithm_t bmv080_measurement_algorithm = (bmv080_measurement_algorithm_t)measurement_algorithm;
+    bmv080_status_code_t bmv080_current_status =
+        bmv080_set_parameter(bmv080_handle_class, "measurement_algorithm", (void *)&bmv080_measurement_algorithm);
+    if (bmv080_current_status != E_BMV080_OK)
+    {
+        printf("Error setting BMV080 Measurement Algorithm: %d\n", bmv080_current_status);
+        return false;
+    }
+    else
+    {
+        return true;
+    }
 }
diff --git a/src/sfeBmv080.h b/src/sfeBmv080.h
@@ -89,6 +89,10 @@ class sfeBmv080
     /// @return The PM2.5 value as a float in ug/m3
     float getPM25();
 
+    /// @brief Get the PM1 value
+    /// @return The PM1 value as a float in ug/m3
+    float getPM1();
+
     /// @brief Get the obstruction status
     /// @return True if obstructed, false otherwise
     bool getIsObstructed();
@@ -155,6 +159,15 @@ class sfeBmv080
     /// @return True if successful, false otherwise
     bool setDoVibrationFiltering(bool do_vibration_filtering);
 
+    /// @brief Get a parameter: "measurement_algorithm"
+    /// @return uint8_t measurement_algorithm
+    uint8_t getMeasurementAlgorithm();
+
+    /// @brief Set a parameter: "measurement_algorithm"
+    /// @param measurement_algorithm
+    /// @return True if successful, false otherwise
+    bool setMeasurementAlgorithm(uint8_t measurement_algorithm);
+
   private:
     bmv080_handle_t bmv080_handle_class = NULL;
     bool _dataAvailable = false;

Original file line number	Diff line number	Diff line change
`@@ -75,8 +75,11 @@ void loop()`
`75`	`75`	`if (bmv080.dataAvailable())`
`76`	`76`	`{`
`77`	`77`	`float pm25 = bmv080.getPM25();`
	`78`	`+ float pm1 = bmv080.getPM1();`
`78`	`79`
`79`	`80`	`Serial.print(pm25);`
	`81`	`+ Serial.print("\t");`
	`82`	`+ Serial.print(pm1);`
`80`	`83`
`81`	`84`	`if (bmv080.getIsObstructed() == true)`
`82`	`85`	`{`