Sensor-Parameter

Was dieses Beispiel zeigt

Lesen und optional Ändern der Einstellungen, mit denen der Bosch-Driver die Rohdaten des Sensors in PM-Werte umrechnet: volumetrische Massendichte, Integrationszeit, Verteilungs-ID, Obstruction Detection, Vibrationsfilterung und Messalgorithmus. Das Beispiel gibt den aktuellen Wert jeder Einstellung aus, startet dann die kontinuierliche Messung und gibt PM10, PM2.5 und PM1 aus, wie das Beispiel PM-Werte lesen.

Die Zeilen, die die Einstellungen ändern, stehen in read_configure_parameters() in einem Kommentarblock. Entfernen Sie das /* und das */ darum und passen Sie die Werte an, um Ihre eigenen anzuwenden. Sie laufen vor setMode(), und dort müssen sie auch stehen: Der Sensor übernimmt seine Einstellungen, wenn die Messung startet.

Der Beispielcode

Dies ist Parameters.ino aus der fest eingebundenen Library, ohne den Header-Kommentar. Der Sketch selbst entspricht genau der ausgelieferten Fassung. Er verwendet die Standardadresse des Boards, 0x57.

Select Board

Parameters.ino

#include "Wire.h"
#include "BMV080-SOLDERED.h"

BMV080 bmv080;              // Create and instance of the BMV080 class
#define BMV080_ADDR 0x57    // BMV080 default I2C address

void setup()
{
    Serial.begin(115200);

    // Wait for serial to become available
    while (!Serial) delay(10);

    Wire.begin();

    // Attempt to initialize the sensor via I2C
    if (bmv080.begin(BMV080_ADDR, Wire) == false) 
    {
        Serial.println("BMV080 not detected");
        while (1)
        ;
    }
    Serial.println("BMV080 found!");

    // Initialize the sensor
    if (bmv080.init())
    {
        Serial.println("BMV sensor initialized");
    }
    else
    {
        Serial.println("BMV initialization failed");
        while (1)
        ;
    }

    // Read (and optionaly configure) sensor parameters
    read_configure_parameters();

    // Set the sensor mode to continuous mode
    if(bmv080.setMode(BMV080_MODE_CONTINUOUS) == true)
    {
        Serial.println("BMV080 set to continuous mode");
    }
    else
    {
        Serial.println("Error setting BMV080 mode");
    }
}

void loop()
{
    // Attempt to read new measurement data from the sensor
    if (bmv080.readSensor())
    {
        float pm10 = bmv080.PM10();
        float pm25 = bmv080.PM25();
        float pm1 = bmv080.PM1();

        Serial.print("PM10: ");
        Serial.print(pm10);
        Serial.print("\t");
        Serial.print("PM2.5: ");
        Serial.print(pm25);
        Serial.print("\t");
        Serial.print("PM1: ");
        Serial.print(pm1);

        if (bmv080.isObstructed() == true)
        {
            Serial.print("\tObstructed");
        }

        Serial.println();
    }
    delay(100);
}

// Function which reads current configuration state of BMV080 sensor
// and shows you how to set those parameters to custom values
void read_configure_parameters(void)
{
    // Variables to store the parameters, will be used for storing 
    // current values, and (optionaly) setting custom values for each parameter

    float volumetric_mass_density = 0.0f;
    float integration_time = 0.0f;
    uint32_t distribution_id = 0;
    bool do_obstruction_detection = false;
    bool do_vibration_filtering = false;
    uint8_t measurementAlgorithm = E_BMV080_MEASUREMENT_ALGORITHM_BALANCED;

    // ===========================================================
    //          Reading current configuration parameters 
    // ===========================================================

    // Get default parameter "volumetric_mass_density"
    volumetric_mass_density = bmv080.volumetricMassDensity();
    Serial.print("BMV080 'volumetric_mass_density' current value: ");
    Serial.println(volumetric_mass_density);

    // Get default parameter "integration_time"
    integration_time = bmv080.integrationTime();
    Serial.print("BMV080 'integration_time' current value: ");
    Serial.println(integration_time);

    // Get default parameter "distribution_id"
    distribution_id = bmv080.distributionId();
    Serial.print("BMV080 'distribution_id' current value: ");
    Serial.println(distribution_id);

    // Get default parameter "do_obstruction_detection"
    do_obstruction_detection = bmv080.doObstructionDetection();
    Serial.print("BMV080 'do_obstruction_detection' current value: ");
    if(do_obstruction_detection == true)
    {
        Serial.println("true");
    }
    else
    {
        Serial.println("false");
    }

    // Get default parameter "do_vibration_filtering"
    do_vibration_filtering = bmv080.doVibrationFiltering();
    Serial.print("BMV080 'do_vibration_filtering' current value: ");
    if(do_vibration_filtering == true)
    {
        Serial.println("true");
    }
    else
    {
        Serial.println("false");
    }

    // Get default parameter "measurement_algorithm"
    measurementAlgorithm = bmv080.measurementAlgorithm();
    Serial.print("BMV080 'measurement_algorithm' current value: ");
    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;
    }

    // ===========================================================
    //          Setting new configuration parameters 
    // ===========================================================


    // Uncomment the following lines below to set the parameters to custom values

    /*
    volumetric_mass_density = 1.6f;
    integration_time = 10.0f;
    distribution_id = 3;
    do_obstruction_detection = true;
    do_vibration_filtering = false;
    measurementAlgorithm = E_BMV080_MEASUREMENT_ALGORITHM_BALANCED;

    Serial.println("----- Setting new parameters -----");

    // Set custom parameter "volumetric_mass_density" 
    if(bmv080.setVolumetricMassDensity(volumetric_mass_density) == true)
    {
        Serial.print("BMV080 volumetric_mass_density SET TO: ");
        Serial.println(volumetric_mass_density);
    }
    else
    {
        Serial.println("Error setting BMV080 parameter 'volumetric_mass_density'");
    }

    // Set custom parameter "integration_time" 
    if(bmv080.setIntegrationTime(integration_time) == true)
    {
        Serial.print("BMV080 integration_time SET TO: ");
        Serial.println(integration_time);
    }
    else
    {
        Serial.println("Error setting BMV080 parameter 'integration_time'");
    }

    // Set custom parameter "distribution_id" 
    if(bmv080.setDistributionId(distribution_id) == true)
    {
        Serial.print("BMV080 distribution_id SET TO: ");
        Serial.println(distribution_id);
    }
    else
    {
        Serial.println("Error setting BMV080 parameter 'distribution_id'");
    }

    // Set custom parameter "do_obstruction_detection" 
    if(bmv080.setDoObstructionDetection(do_obstruction_detection) == true)
    {
        Serial.print("BMV080 do_obstruction_detection SET TO: ");
        if(do_obstruction_detection == true)
        {
            Serial.println("true");
        }
        else
        {
            Serial.println("false");
        }
    }
    else
    {
        Serial.println("Error setting BMV080 parameter 'do_obstruction_detection'");
    }

    // Set custom parameter "do_vibration_filtering"
    if(bmv080.setDoVibrationFiltering(do_vibration_filtering) == true)
    {
        Serial.print("BMV080 do_vibration_filtering SET TO: ");
        if(do_vibration_filtering == true)
        {
            Serial.println("true");
        }
        else
        {
            Serial.println("false");
        }
    }
    else
    {
        Serial.println("Error setting BMV080 parameter 'do_vibration_filtering'");
    }

    // Set custom parameter "measurement_algorithm"
    if (bmv080.setMeasurementAlgorithm(measurementAlgorithm) == true)
    {
        Serial.print("BMV080 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();
    */
}

Erwartetes Ergebnis, aus einem Testlauf auf diesem Board (beim Lauf wurde nicht festgehalten, welcher Controller verwendet wurde):

Serial MonitorAutoscrollShow timestampNewline115200 baud

Message (Enter to send message to the board)

BMV080 found!
BMV sensor initialized
BMV080 'volumetric_mass_density' current value: 1.60
BMV080 'integration_time' current value: 10.00
BMV080 'distribution_id' current value: 3
BMV080 'do_obstruction_detection' current value: true
BMV080 'do_vibration_filtering' current value: false
BMV080 'measurement_algorithm' current value: High Precision
BMV080 set to continuous mode
PM10: 9.88	PM2.5: 7.15	PM1: 5.07
PM10: 10.12	PM2.5: 7.33	PM1: 5.18
PM10: 9.95	PM2.5: 7.21	PM1: 5.11

Die sechs current value-Zeilen zeigen die Einstellungen des Sensors, wie der unveränderte Sketch sie liest. Nach BMV080 set to continuous mode erscheint etwa einmal pro Sekunde eine Zeile mit den PM-Werten in µg/m³. Ihre PM-Werte hängen von der Luft um den Sensor ab.

Verwendete Funktionen

BMV080()returns None

Erzeugt das Sensorobjekt. Es nimmt keine Argumente entgegen: Adresse und Wire-Port werden an begin() übergeben.

ReturnsKonstruktor; kein Rückgabewert.

begin(const uint8_t address = BMV080_DEFAULT_ADDRESS, TwoWire &wirePort = Wire)returns bool

Legt die I2C-Adresse und den Wire-Port fest, die die Library verwendet, und prüft, ob der Sensor unter dieser Adresse antwortet. Der I2C-Bus wird dabei nicht gestartet, rufen Sie daher zuerst Wire.begin() auf, wie im Beispiel.

Returnstrue, wenn der Sensor unter der Adresse geantwortet hat, sonst false.

Parameter

Name	Typ	Beschreibung
`address`	`uint8_t`	Die I2C-Adresse des Sensors. Standardmäßig `BMV080_DEFAULT_ADDRESS`, also `0x57`, die Standardadresse des Boards.
`wirePort`	`TwoWire &`	Der zu verwendende I2C-Port. Standardmäßig `Wire`.

init()returns bool

Bereitet den Sensor über den Bosch-Driver vor: liest die Driver-Version, öffnet den Sensor, führt einen Soft-Reset durch und liest die ID des Sensors. Rufen Sie sie nach begin() und vor allem anderen auf.

Returnstrue, wenn alle Schritte erfolgreich waren, false, wenn einer fehlgeschlagen ist.

volumetricMassDensity()returns float

Liest die Partikeldichte, mit der der Driver Partikelmessungen in Massenkonzentration umrechnet.

ReturnsDie Dichte in g/cm³ oder 0.0, wenn sie nicht gelesen werden konnte.

setVolumetricMassDensity(float volumetric_mass_density)returns bool

Legt die Partikeldichte fest, die für die Massenkonzentration verwendet wird. Der im Beispiel vorgeschlagene Wert ist 1.6.

Returnstrue, wenn der Wert gesetzt wurde, sonst false.

Parameter

Name	Typ	Beschreibung
`volumetric_mass_density`	`float`	Die Partikeldichte in g/cm³.

integrationTime()returns float

Liest die Integrationszeit: das Messfenster, über das der Sensor einen PM-Wert berechnet. Im Duty-Cycling-Modus umfasst sie zusätzlich die Zeit, in der der Sensor eingeschaltet ist.

ReturnsDie Integrationszeit in Sekunden (standardmäßig 10) oder 0.0, wenn sie nicht gelesen werden konnte.

setIntegrationTime(float integration_time)returns bool

Legt die Integrationszeit fest. Der im Beispiel vorgeschlagene Wert ist 10.0, der Bosch-Standardwert.

Returnstrue, wenn der Wert gesetzt wurde, sonst false.

Parameter

Name	Typ	Beschreibung
`integration_time`	`float`	Das Messfenster in Sekunden.

distributionId()returns uint32_t

Liest die Verteilungs-ID: das Modell der Partikelgrößenverteilung, mit dem der Driver Partikel klassifiziert.

ReturnsDie Verteilungs-ID oder 0, wenn sie nicht gelesen werden konnte.

setDistributionId(uint32_t distribution_id)returns bool

Wählt das Modell der Partikelgrößenverteilung aus. Der im Beispiel vorgeschlagene Wert ist 3.

Returnstrue, wenn der Wert gesetzt wurde, sonst false.

Parameter

Name	Typ	Beschreibung
`distribution_id`	`uint32_t`	Die zu verwendende Verteilungs-ID.

doObstructionDetection()returns bool

Liest, ob die Obstruction Detection eingeschaltet ist. Ist sie eingeschaltet, meldet isObstructed() einen blockierten optischen Pfad.

Returnstrue, wenn die Obstruction Detection eingeschaltet ist, false, wenn sie ausgeschaltet ist oder nicht gelesen werden konnte.

setDoObstructionDetection(bool do_obstruction_detection)returns bool

Schaltet die Obstruction Detection ein oder aus.

Returnstrue, wenn die Einstellung geändert wurde, sonst false.

Parameter

Name	Typ	Beschreibung
`do_obstruction_detection`	`bool`	`true`, um die Obstruction Detection einzuschalten, `false`, um sie auszuschalten.

doVibrationFiltering()returns bool

Liest, ob die Vibrationsfilterung eingeschaltet ist.

Returnstrue, wenn die Vibrationsfilterung eingeschaltet ist, false, wenn sie ausgeschaltet ist oder nicht gelesen werden konnte.

setDoVibrationFiltering(bool do_vibration_filtering)returns bool

Schaltet die Vibrationsfilterung ein oder aus.

Returnstrue, wenn die Einstellung geändert wurde, sonst false.

Parameter

Name	Typ	Beschreibung
`do_vibration_filtering`	`bool`	`true`, um die Vibrationsfilterung einzuschalten, `false`, um sie auszuschalten.

measurementAlgorithm()returns uint8_t

Liest, welchen Messalgorithmus der Driver verwendet.

ReturnsE_BMV080_MEASUREMENT_ALGORITHM_FAST_RESPONSE (1), E_BMV080_MEASUREMENT_ALGORITHM_BALANCED (2) oder E_BMV080_MEASUREMENT_ALGORITHM_HIGH_PRECISION (3), oder 0, wenn er nicht gelesen werden konnte.

setMeasurementAlgorithm(uint8_t measurement_algorithm)returns bool

Wählt den Messalgorithmus aus. Fast Response liefert die schnellste Reaktion, High Precision die höchste Genauigkeit, und Balanced liegt zwischen beiden. High Precision ist der Bosch-Standardwert. Duty-Cycling verwendet immer Fast Response.

Returnstrue, wenn der Algorithmus gesetzt wurde, sonst false.

Parameter

Name	Typ	Beschreibung
`measurement_algorithm`	`uint8_t`	Einer der Werte `E_BMV080_MEASUREMENT_ALGORITHM_FAST_RESPONSE`, `E_BMV080_MEASUREMENT_ALGORITHM_BALANCED` oder `E_BMV080_MEASUREMENT_ALGORITHM_HIGH_PRECISION`.

setMode(uint8_t mode)returns bool

Startet die Messung im gewählten Modus, mit den zuvor vorgenommenen Einstellungen.

Returnstrue, wenn der Bosch-Driver die Messung gestartet hat, sonst false.

Parameter

Name	Typ	Beschreibung
`mode`	`uint8_t`	`BMV080_MODE_CONTINUOUS` für kontinuierliche Messung, wie hier, oder `BMV080_MODE_DUTY_CYCLE` für Duty-Cycling.

readSensor(bmv080_output_t *bmv080_output = nullptr)returns bool

Lässt den Bosch-Driver einmal Daten vom Sensor abrufen und verarbeiten. Trifft ein neuer Messwert ein, speichert die Library ihn für PM10(), PM25(), PM1() und isObstructed().

Returnstrue, wenn während dieses Aufrufs ein neuer Messwert eingetroffen ist, sonst false.

Parameter

Name	Typ	Beschreibung
`bmv080_output`	`bmv080_output_t *`	Optional. Eine Bosch-Ausgabestruktur, in die der neue Messwert kopiert wird. Das Beispiel lässt sie weg.

PM10()returns float

Gibt den PM10-Wert der letzten Messung zurück: Partikel mit einem Durchmesser von 10 µm oder kleiner.

ReturnsPM10-Massenkonzentration in µg/m³.

PM25()returns float

Gibt den PM2.5-Wert der letzten Messung zurück: Partikel mit einem Durchmesser von 2,5 µm oder kleiner.

ReturnsPM2.5-Massenkonzentration in µg/m³.

PM1()returns float

Gibt den PM1-Wert der letzten Messung zurück: Partikel mit einem Durchmesser von 1 µm oder kleiner.

ReturnsPM1-Massenkonzentration in µg/m³.

isObstructed()returns bool

Gibt das Obstruction-Flag der letzten Messung zurück. Der Sensor setzt es, wenn sich ein fester Gegenstand in seinem optischen Pfad befindet.

Returnstrue, wenn die letzte Messung blockiert war, sonst false.

Zusammenfassung

Lesen oder ändern Sie die Einstellungen nach init() und vor setMode(). Jeder Getter gibt 0, 0.0 oder false zurück, wenn der Driver die Einstellung nicht lesen konnte, und jeder Setter gibt nur dann true zurück, wenn der Driver den neuen Wert akzeptiert hat. Prüfen Sie daher das Ergebnis, bevor Sie sich darauf verlassen.

QuelleDas geprüfte Arduino-Beispiel öffnenDen genauen Quellcode ansehen, der auf dieser Seite verwendet wird.examples/Parameters/Parameters.ino

Was dieses Beispiel zeigt​

Der Beispielcode​

Verwendete Funktionen​

Zusammenfassung​

Was dieses Beispiel zeigt

Der Beispielcode

Verwendete Funktionen

Zusammenfassung