Skip to main content

Parametri senzora

Što prikazuje ovaj primjer​

Čitanje i, po želji, promjena postavki koje Bosch upravljački program koristi za pretvaranje sirovih podataka senzora u PM vrijednosti: volumna gustoća mase, vrijeme integracije, ID distribucije, detekcija zapreke, filtriranje vibracija i algoritam mjerenja. Primjer ispisuje trenutnu vrijednost svake od njih, zatim pokreće kontinuirano mjerenje i ispisuje PM10, PM2.5 i PM1 kao primjer Čitanje PM vrijednosti.

Linije koje mijenjaju postavke nalaze se unutar komentara u read_configure_parameters(). Uklonite /* i */ oko njih i uredite vrijednosti kako biste primijenili vlastite. Izvršavaju se prije setMode(), što je i jedino ispravno mjesto: senzor preuzima svoje postavke kad mjerenje počne.

Kôd primjera​

Ovo je Parameters.ino iz fiksirane (pinned) verzije biblioteke, bez uvodnog komentara. Skica je potpuno jednaka isporučenoj. Koristi zadanu adresu pločice, 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();
    */
}

Očekivani rezultat, iz ispitivanja na radnom stolu s ovom pločicom (u ispitivanju nije zabilježeno koji je kontroler korišten):

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

Šest linija current value prikazuje postavke senzora onako kako ih čita neizmijenjena skica. Nakon BMV080 set to continuous mode otprilike jednom u sekundi pojavljuje se linija s PM vrijednostima u µg/m³. Vaše PM vrijednosti ovise o zraku oko senzora.

Korištene funkcije​

BMV080()returns None

Stvara objekt senzora. Ne prima argumente: adresa i Wire port zadaju se u begin().

ReturnsKonstruktor; nema povratne vrijednosti.

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

Postavlja I2C adresu i Wire port koje biblioteka koristi te provjerava odgovara li senzor na toj adresi. Ne pokreće I2C sabirnicu, zato prvo pozovite Wire.begin(), kao što to radi primjer.

Returnstrue kad je senzor odgovorio na adresi, inače false.

Parametri

NazivTipOpis
addressuint8_tI2C adresa senzora. Zadano je BMV080_DEFAULT_ADDRESS, a to je 0x57, zadana adresa pločice.
wirePortTwoWire &I2C port koji se koristi. Zadano je Wire.
init()returns bool

Priprema senzor putem Bosch upravljačkog programa: čita verziju upravljačkog programa, otvara senzor, izvodi programski reset i čita ID senzora. Pozovite ga nakon begin() i prije svega ostalog.

Returnstrue kad su svi koraci uspjeli, false kad je neki zakazao.

volumetricMassDensity()returns float

Čita gustoću čestica koju upravljački program koristi za pretvaranje mjerenja čestica u masenu koncentraciju.

ReturnsGustoća u g/cm³, ili 0.0 ako se nije mogla pročitati.

setVolumetricMassDensity(float volumetric_mass_density)returns bool

Postavlja gustoću čestica koja se koristi za masenu koncentraciju. Vrijednost koju predlaže primjer je 1.6.

Returnstrue kad je vrijednost postavljena, inače false.

Parametri

NazivTipOpis
volumetric_mass_densityfloatGustoća čestica u g/cm³.
integrationTime()returns float

Čita vrijeme integracije: prozor mjerenja unutar kojeg senzor izračunava jednu PM vrijednost. U načinu rada s radnim ciklusom obuhvaća i vrijeme tijekom kojeg je senzor uključen.

ReturnsVrijeme integracije u sekundama (zadano 10), ili 0.0 ako se nije moglo pročitati.

setIntegrationTime(float integration_time)returns bool

Postavlja vrijeme integracije. Vrijednost koju predlaže primjer je 10.0, zadana Boschova vrijednost.

Returnstrue kad je vrijednost postavljena, inače false.

Parametri

NazivTipOpis
integration_timefloatProzor mjerenja u sekundama.
distributionId()returns uint32_t

Čita ID distribucije: model distribucije veličine čestica koji upravljački program koristi za razvrstavanje čestica.

ReturnsID distribucije, ili 0 ako se nije mogao pročitati.

setDistributionId(uint32_t distribution_id)returns bool

Odabire model distribucije veličine čestica. Vrijednost koju predlaže primjer je 3.

Returnstrue kad je vrijednost postavljena, inače false.

Parametri

NazivTipOpis
distribution_iduint32_tID distribucije koji se koristi.
doObstructionDetection()returns bool

Čita je li detekcija zapreke uključena. Kad jest, isObstructed() javlja blokiran optički put.

Returnstrue kad je detekcija zapreke uključena, false kad je isključena ili se nije mogla pročitati.

setDoObstructionDetection(bool do_obstruction_detection)returns bool

Uključuje ili isključuje detekciju zapreke.

Returnstrue kad je postavka promijenjena, inače false.

Parametri

NazivTipOpis
do_obstruction_detectionbooltrue za uključivanje detekcije zapreke, false za isključivanje.
doVibrationFiltering()returns bool

Čita je li filtriranje vibracija uključeno.

Returnstrue kad je filtriranje vibracija uključeno, false kad je isključeno ili se nije moglo pročitati.

setDoVibrationFiltering(bool do_vibration_filtering)returns bool

Uključuje ili isključuje filtriranje vibracija.

Returnstrue kad je postavka promijenjena, inače false.

Parametri

NazivTipOpis
do_vibration_filteringbooltrue za uključivanje filtriranja vibracija, false za isključivanje.
measurementAlgorithm()returns uint8_t

Čita koji algoritam mjerenja koristi upravljački program.

ReturnsE_BMV080_MEASUREMENT_ALGORITHM_FAST_RESPONSE (1), E_BMV080_MEASUREMENT_ALGORITHM_BALANCED (2) ili E_BMV080_MEASUREMENT_ALGORITHM_HIGH_PRECISION (3), ili 0 ako se nije mogao pročitati.

setMeasurementAlgorithm(uint8_t measurement_algorithm)returns bool

Odabire algoritam mjerenja. Brzi odziv daje najbrži odziv, visoka preciznost najbolju preciznost, a uravnotežen algoritam je između ta dva. Visoka preciznost je zadana Boschova vrijednost. Mjerenje s radnim ciklusom uvijek koristi brzi odziv.

Returnstrue kad je algoritam postavljen, inače false.

Parametri

NazivTipOpis
measurement_algorithmuint8_tJedno od: E_BMV080_MEASUREMENT_ALGORITHM_FAST_RESPONSE, E_BMV080_MEASUREMENT_ALGORITHM_BALANCED ili E_BMV080_MEASUREMENT_ALGORITHM_HIGH_PRECISION.
setMode(uint8_t mode)returns bool

Pokreće mjerenje u odabranom načinu rada, s postavkama zadanima prije njega.

Returnstrue kad je Bosch upravljački program pokrenuo mjerenje, inače false.

Parametri

NazivTipOpis
modeuint8_tBMV080_MODE_CONTINUOUS za kontinuirano mjerenje, kao ovdje, ili BMV080_MODE_DUTY_CYCLE za mjerenje s radnim ciklusom.
readSensor(bmv080_output_t *bmv080_output = nullptr)returns bool

Omogućuje Bosch upravljačkom programu da jednom dohvati i obradi podatke sa senzora. Kad stigne novo očitanje, biblioteka ga zadržava za PM10(), PM25(), PM1() i isObstructed().

Returnstrue kad je tijekom ovog poziva stiglo novo očitanje, inače false.

Parametri

NazivTipOpis
bmv080_outputbmv080_output_t *Neobavezno. Boschova izlazna struktura u koju se kopira novo očitanje. Primjer je izostavlja.
PM10()returns float

Vraća PM10 vrijednost najnovijeg očitanja: čestice promjera 10 µm ili manje.

ReturnsPM10 masena koncentracija u µg/m³.

PM25()returns float

Vraća PM2.5 vrijednost najnovijeg očitanja: čestice promjera 2,5 µm ili manje.

ReturnsPM2.5 masena koncentracija u µg/m³.

PM1()returns float

Vraća PM1 vrijednost najnovijeg očitanja: čestice promjera 1 µm ili manje.

ReturnsPM1 masena koncentracija u µg/m³.

isObstructed()returns bool

Vraća oznaku zapreke najnovijeg očitanja. Senzor je postavlja kad se u njegovom optičkom putu nalazi nepomičan predmet.

Returnstrue kad je najnovije očitanje bilo zapriječeno, inače false.

Sve zajedno​

Postavke čitajte ili mijenjajte nakon init() i prije setMode(). Svaki getter vraća 0, 0.0 ili false kad upravljački program nije mogao pročitati postavku, a svaki setter vraća true samo kad je upravljački program prihvatio novu vrijednost, stoga provjerite rezultat prije nego što se na njega oslonite.

IzvorOtvorite provjereni Arduino primjerPogledajte točan izvorni kôd korišten na ovoj stranici.examples/Parameters/Parameters.ino