ex4 SPI

Author: lewispg228

examples/Example_04_SPI/Example_04_SPI.ino

@@ -0,0 +1,89 @@
+/*
+  Using the BMV080 Particulate Matter PM2.5 Sensor with SPI
+
+  This example shows how to use the sensor in "continuous mode" to get
+  particulate matter readings once every second.
+
+  It uses polling of the device to check if new data is available.
+
+  By: Pete Lewis
+  SparkFun Electronics
+  Date: September, 2024
+  SparkFun code, firmware, and software is released under the MIT License.
+	Please see LICENSE.md for further details.
+
+  Hardware Connections:
+  IoT RedBoard  -->     BMV080
+  ------------------------------
+  GND           -->     GND
+  3V3           -->     3V3
+  PICO          -->     PICO (SDA)
+  POCI          -->     POCI (AB0)
+  SCK           -->     SCK (SCL)
+  CS            -->     CS (AB1)
+
+  BMV080 "mode" jumper set to SPI (default)
+
+  Serial.print it out at 115200 baud to serial monitor.
+
+  Feel like supporting our work? Buy a board from SparkFun!
+  https://www.sparkfun.com/products/?????
+*/
+
+#include <Wire.h>
+#include "SparkFun_BMV080_Arduino_Library.h" // CTRL+Click here to get the library: http://librarymanager/All#SparkFun_BMV080
+
+Bmv080 bmv080; // Create an instance of the BMV080 class
+
+spi_device_t spi_device = {}; // SPI device struct instance for Bosch API
+
+void setup()
+{
+    Serial.begin(115200);
+
+    while(!Serial) delay(10); // Wait for Serial to become available.
+    // Necessary for boards with native USB (like the SAMD51 Thing+).
+    // For a final version of a project that does not need serial debug (or a USB cable plugged in),
+    // Comment out this while loop, or it will prevent the remaining code from running.
+
+    Serial.println();
+    Serial.println("BMV080 Example 4 - SPI");
+
+    /* Communication interface initialization */
+    spi_init(&spi_device);
+
+    if (bmv080.initSPI(&spi_device) == false) {
+        Serial.println("SPI init failure. Check your jumpers and the hookup guide. Freezing...");
+        while (1)
+        ;
+    }
+    Serial.println("BMV080 SPI init successful");
+
+    /* Set the sensor mode to continuous mode */
+    if(bmv080.setMode(SFE_BMV080_MODE_CONTINUOUS) == true)
+    {
+        Serial.println("BMV080 set to continuous mode");
+    }
+    else
+    {
+        Serial.println("Error setting BMV080 mode");
+    }
+}
+
+void loop()
+{
+    if(bmv080.dataAvailable())
+    {
+        float pm25 = bmv080.getPM25();
+
+        Serial.print(pm25);
+
+        if(bmv080.getIsObstructed() == true)
+        {
+            Serial.print("\tObstructed");
+        }
+
+        Serial.println();
+    }
+    delay(100);
+}

src/sfeBmv080.cpp

@@ -178,8 +178,6 @@ bool sfeBmv080::init(i2c_device_t *i2c_device)
 
 bool sfeBmv080::open(i2c_device_t *i2c_device)
 {
-    //bmv080_handle_t bmv080_handle_temp = NULL;
-    //setHandle(bmv080_handle_temp);
     bmv080_sercom_handle_t sercom_handle = (bmv080_sercom_handle_t)i2c_device;
     bmv080_callback_read_t read = (const bmv080_callback_read_t)combridge_i2c_read_16bit;
     bmv080_callback_write_t write = (const bmv080_callback_write_t)combridge_i2c_write_16bit;
@@ -199,6 +197,52 @@ bool sfeBmv080::open(i2c_device_t *i2c_device)
     }
 }
 
+bool sfeBmv080::initSPI(spi_device_t *spi_device)
+{
+    if(getDriverVersion() == false)
+    {
+        return false;
+    }
+
+    if(openSPI(spi_device) == false)
+    {
+        return false;
+    }
+
+    if(reset() == false)
+    {
+        return false;
+    }
+
+    if(getID() == false)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+bool sfeBmv080::openSPI(spi_device_t *spi_device)
+{
+    bmv080_sercom_handle_t sercom_handle = (bmv080_sercom_handle_t)spi_device;
+    bmv080_callback_read_t read = (const bmv080_callback_read_t)combridge_spi_read_16bit;
+    bmv080_callback_write_t write = (const bmv080_callback_write_t)combridge_spi_write_16bit;
+    bmv080_callback_delay_t delay_ms = (const bmv080_callback_delay_t)combridge_delay;
+
+    bmv080_status_code_t bmv080_current_status = bmv080_open(&bmv080_handle_class, sercom_handle, read, write, delay_ms);
+
+    if (bmv080_current_status != E_BMV080_OK)
+    {
+        Serial.println("BMV080 open failed");
+        return false;
+    }
+    else
+    {
+        Serial.println("BMV080 open successfully");
+        return true;
+    }
+}
+
 bool sfeBmv080::reset()
 {
     bmv080_status_code_t bmv080_current_status = bmv080_reset(bmv080_handle_class);

src/sfeBmv080.h

@@ -53,13 +53,20 @@ class sfeBmv080
     /// @return 0 for succuss, negative for errors, positive for warnings
     sfeTkError_t isConnected();
 
-    /// @brief Initialize the sensor
+    /// @brief Initialize the sensor i2c
     /// @details This function initializes the sensor and should be called 
-    /// before any other functions. It calls Open, Reset, getDriverVersion, and getID.
+    /// @details before any other functions. It calls Open, Reset, getDriverVersion, and getID.
     /// @param i2c_device The I2C device to use
     /// @return True if successful, false otherwise
     bool init(i2c_device_t *i2c_device);
 
+    /// @brief Initialize the sensor SPI
+    /// @details This function initializes the sensor and should be called
+    /// @details before any other functions. It calls Open, Reset, getDriverVersion, and getID.
+    /// @param spi_device The SPI device to use
+    /// @return True if successful, false otherwise
+    bool initSPI(spi_device_t *spi_device);
+
     /// @brief Get the version information of this sensor driver.
     /// @return True if successful, false otherwise
     bool getDriverVersion();
@@ -69,6 +76,11 @@ class sfeBmv080
     /// @return True if successful, false otherwise
     bool open(i2c_device_t *i2c_device);
 
+    /// @brief Open a sensor unit by initializing a new handle.
+    /// @param spi_device The SPI device to use
+    /// @return True if successful, false otherwise
+    bool openSPI(spi_device_t *spi_device);
+
     /// @brief Reset the sensor
     /// @return True if successful, false otherwise
     bool reset();