Initial Release

spi/bme280_spi/CMakeLists.txt

@@ -0,0 +1,12 @@
+add_executable(bme280_spi
+        bme280_spi.c
+        )
+
+# Pull in our (to be renamed) simple get you started dependencies
+target_link_libraries(bme280_spi pico_stdlib hardware_spi)
+
+# create map/bin/hex file etc.
+pico_add_extra_outputs(bme280_spi)
+
+# add url via pico_set_program_url
+example_auto_set_url(bme280_spi)

spi/bme280_spi/README.adoc

@@ -0,0 +1,50 @@
+= Attaching a BME280 temperature/humidity/pressure sensor via SPI
+
+This example code shows how to interface the Raspberry Pi Pico to a BME280 temperature/humidity/pressure. The particular device used can be interfaced via I2C or SPI, we are using SPI, and interfacing at 3.3v.
+
+This examples reads the data from the sensor, and runs it through the appropriate compensation routines (see the chip datasheet for details https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bme280-ds002.pdf). At startup the compensation parameters required by the compensation routines are read from the chip.
+)
+
+== Wiring information
+
+Wiring up the device requires 6 jumpers as follows:
+
+   * GPIO 16 (pin 21) MISO/spi0_rx-> SDO/SDO on bme280 board
+   * GPIO 17 (pin 22) Chip select -> CSB/!CS on bme280 board
+   * GPIO 18 (pin 24) SCK/spi0_sclk -> SCL/SCK on bme280 board
+   * GPIO 19 (pin 25) MOSI/spi0_tx -> SDA/SDI on bme280 board
+   * 3.3v (pin 3;6) -> VCC on bme280 board
+   * GND (pin 38)  -> GND on bme280 board
+
+The example here uses SPI port 0. Power is supplied from the 3.3V pin.
+
+[NOTE]
+======
+There are many different manufacturers who sell boards with the BME280. Whilst they all appear slightly different, they all have, at least, the same 6 pins required to power and communicate. When wiring up a board that is different to the one in the diagram, ensure you connect up as described in the previous paragraph.
+======
+
+
+[[BME280_spi_wiring]]
+[pdfwidth=75%]
+.Wiring Diagram for bme280.
+image::bme280_spi_bb.png[]
+
+== List of Files
+
+CMakeLists.txt:: CMake file to incorporate the example in to the examples build tree.
+bme280_spi.c:: The example code.
+
+== Bill of Materials
+
+.A list of materials required for the example
+[[BME280-bom-table]]
+[cols=3]
+|===
+| *Item* | *Quantity* | Details
+| Breadboard | 1 | generic part
+| Raspberry Pi Pico | 1 | http://raspberrypi.org/
+| BME280 board| 1 | generic part
+| M/M Jumper wires | 6 | generic part
+|===
+
+

spi/bme280_spi/bme280_spi.c

@@ -0,0 +1,233 @@
+/**
+ * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "pico/stdlib.h"
+#include "hardware/spi.h"
+
+/* Example code to talk to a bme280 humidity/temperature/pressure sensor.
+
+   NOTE: Ensure the device is capable of being driven at 3.3v NOT 5v. The Pico
+   GPIO (and therefor SPI) cannot be used at 5v.
+
+   You will need to use a level shifter on the SPI lines if you want to run the
+   board at 5v.
+
+   Connections on Raspberry Pi Pico board and a generic bme280 board, other
+   boards may vary.
+
+   GPIO 16 (pin 21) MISO/spi0_rx-> SDO/SDO on bme280 board
+   GPIO 17 (pin 22) Chip select -> CSB/!CS on bme280 board
+   GPIO 18 (pin 24) SCK/spi0_sclk -> SCL/SCK on bme280 board
+   GPIO 19 (pin 25) MOSI/spi0_tx -> SDA/SDI on bme280 board
+   3.3v (pin 3;6) -> VCC on bme280 board
+   GND (pin 38)  -> GND on bme280 board
+
+   Note: SPI devices can have a number of different naming schemes for pins. See
+   the Wikipedia page at https://en.wikipedia.org/wiki/Serial_Peripheral_Interface
+   for variations.
+
+   This code uses a bunch of register definitions, and some compensation code derived
+   from the Bosch datasheet which can be found here.
+   https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bme280-ds002.pdf
+*/
+
+#define PIN_MISO 16
+#define PIN_CS   17
+#define PIN_SCK  18
+#define PIN_MOSI 19
+
+#define SPI_PORT spi0
+#define READ_BIT 0x80
+
+int32_t t_fine;
+
+uint16_t dig_T1;
+int16_t dig_T2, dig_T3;
+uint16_t dig_P1;
+int16_t dig_P2, dig_P3, dig_P4, dig_P5, dig_P6, dig_P7, dig_P8, dig_P9;
+uint8_t dig_H1, dig_H3;
+int8_t dig_H6;
+int16_t dig_H2, dig_H4, dig_H5;
+
+/* The following compensation functions are required to convert from the raw ADC
+data from the chip to something usable. Each chip has a different set of
+compensation parameters stored on the chip at point of manufacture, which are
+read from the chip at startup and used inthese routines.
+*/
+int32_t compensate_temp(int32_t adc_T) {
+    int32_t var1, var2, T;
+    var1 = ((((adc_T >> 3) - ((int32_t) dig_T1 << 1))) * ((int32_t) dig_T2)) >> 11;
+    var2 = (((((adc_T >> 4) - ((int32_t) dig_T1)) * ((adc_T >> 4) - ((int32_t) dig_T1))) >> 12) * ((int32_t) dig_T3))
+            >> 14;
+
+    t_fine = var1 + var2;
+    T = (t_fine * 5 + 128) >> 8;
+    return T;
+}
+
+uint32_t compensate_pressure(int32_t adc_P) {
+    int32_t var1, var2;
+    uint32_t p;
+    var1 = (((int32_t) t_fine) >> 1) - (int32_t) 64000;
+    var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((int32_t) dig_P6);
+    var2 = var2 + ((var1 * ((int32_t) dig_P5)) << 1);
+    var2 = (var2 >> 2) + (((int32_t) dig_P4) << 16);
+    var1 = (((dig_P3 * (((var1 >> 2) * (var1 >> 2)) >> 13)) >> 3) + ((((int32_t) dig_P2) * var1) >> 1)) >> 18;
+    var1 = ((((32768 + var1)) * ((int32_t) dig_P1)) >> 15);
+    if (var1 == 0)
+        return 0;
+
+    p = (((uint32_t) (((int32_t) 1048576) - adc_P) - (var2 >> 12))) * 3125;
+    if (p < 0x80000000)
+        p = (p << 1) / ((uint32_t) var1);
+    else
+        p = (p / (uint32_t) var1) * 2;
+
+    var1 = (((int32_t) dig_P9) * ((int32_t) (((p >> 3) * (p >> 3)) >> 13))) >> 12;
+    var2 = (((int32_t) (p >> 2)) * ((int32_t) dig_P8)) >> 13;
+    p = (uint32_t) ((int32_t) p + ((var1 + var2 + dig_P7) >> 4));
+
+    return p;
+}
+
+uint32_t compensate_humidity(int32_t adc_H) {
+    int32_t v_x1_u32r;
+    v_x1_u32r = (t_fine - ((int32_t) 76800));
+    v_x1_u32r = (((((adc_H << 14) - (((int32_t) dig_H4) << 20) - (((int32_t) dig_H5) * v_x1_u32r)) +
+                   ((int32_t) 16384)) >> 15) * (((((((v_x1_u32r * ((int32_t) dig_H6)) >> 10) * (((v_x1_u32r *
+                                                                                                  ((int32_t) dig_H3))
+            >> 11) + ((int32_t) 32768))) >> 10) + ((int32_t) 2097152)) *
+                                                 ((int32_t) dig_H2) + 8192) >> 14));
+    v_x1_u32r = (v_x1_u32r - (((((v_x1_u32r >> 15) * (v_x1_u32r >> 15)) >> 7) * ((int32_t) dig_H1)) >> 4));
+    v_x1_u32r = (v_x1_u32r < 0 ? 0 : v_x1_u32r);
+    v_x1_u32r = (v_x1_u32r > 419430400 ? 419430400 : v_x1_u32r);
+
+    return (uint32_t) (v_x1_u32r >> 12);
+}
+
+static inline void cs_select() {
+    asm volatile("nop \n nop \n nop");
+    gpio_put(PIN_CS, 0);  // Active low
+    asm volatile("nop \n nop \n nop");
+}
+
+static inline void cs_deselect() {
+    asm volatile("nop \n nop \n nop");
+    gpio_put(PIN_CS, 1);
+    asm volatile("nop \n nop \n nop");
+}
+
+static void write_register(uint8_t reg, uint8_t data) {
+    uint8_t buf[2];
+    buf[0] = reg & 0x7f;  // remove read bit as this is a write
+    buf[1] = data;
+    cs_select();
+    spi_write_blocking(SPI_PORT, buf, 2);
+    cs_deselect();
+    sleep_ms(10);
+}
+
+static void read_registers(uint8_t reg, uint8_t *buf, uint16_t len) {
+    // For this particular device, we send the device the register we want to read
+    // first, then subsequently read from the device. The register is auto incrementing
+    // so we don't need to keep sending the register we want, just the first.
+    reg |= READ_BIT;
+    cs_select();
+    spi_write_blocking(SPI_PORT, &reg, 1);
+    sleep_ms(10);
+    spi_read_blocking(SPI_PORT, 0, buf, len);
+    cs_deselect();
+    sleep_ms(10);
+}
+
+/* This function reads the manufacturing assigned compensation parameters from the device */
+void read_compensation_parameters() {
+    uint8_t buffer[26];
+
+    read_registers(0x88, buffer, 24);
+
+    dig_T1 = buffer[0] | (buffer[1] << 8);
+    dig_T2 = buffer[2] | (buffer[3] << 8);
+    dig_T3 = buffer[4] | (buffer[5] << 8);
+
+    dig_P1 = buffer[6] | (buffer[7] << 8);
+    dig_P2 = buffer[8] | (buffer[9] << 8);
+    dig_P3 = buffer[10] | (buffer[11] << 8);
+    dig_P4 = buffer[12] | (buffer[13] << 8);
+    dig_P5 = buffer[14] | (buffer[15] << 8);
+    dig_P6 = buffer[16] | (buffer[17] << 8);
+    dig_P7 = buffer[18] | (buffer[19] << 8);
+    dig_P8 = buffer[20] | (buffer[21] << 8);
+    dig_P9 = buffer[22] | (buffer[23] << 8);
+
+    dig_H1 = buffer[25];
+
+    read_registers(0xE1, buffer, 8);
+
+    dig_H2 = buffer[0] | (buffer[1] << 8);
+    dig_H3 = (int8_t) buffer[2];
+    dig_H4 = buffer[3] << 4 | (buffer[4] & 0xf);
+    dig_H5 = (buffer[5] >> 4) | (buffer[6] << 4);
+    dig_H6 = (int8_t) buffer[7];
+}
+
+static void bme280_read_raw(int32_t *humidity, int32_t *pressure, int32_t *temperature) {
+    uint8_t buffer[8];
+
+    read_registers(0xF7, buffer, 8);
+    *pressure = ((uint32_t) buffer[0] << 12) | ((uint32_t) buffer[1] << 4) | (buffer[2] >> 4);
+    *temperature = ((uint32_t) buffer[3] << 12) | ((uint32_t) buffer[4] << 4) | (buffer[5] >> 4);
+    *humidity = (uint32_t) buffer[6] << 8 | buffer[7];
+}
+
+int main() {
+    stdio_init_all();
+
+    printf("Hello, bme280! Reading raw data from registers via SPI...\n");
+
+    // This example will use SPI0 at 0.5MHz.
+    spi_init(SPI_PORT, 500 * 1000);
+    gpio_set_function(PIN_MISO, GPIO_FUNC_SPI);
+    gpio_set_function(PIN_SCK, GPIO_FUNC_SPI);
+    gpio_set_function(PIN_MOSI, GPIO_FUNC_SPI);
+
+    // Chip select is active-low, so we'll initialise it to a driven-high state
+    gpio_init(PIN_CS);
+    gpio_set_dir(PIN_CS, GPIO_OUT);
+    gpio_put(PIN_CS, 1);
+
+    // See if SPI is working - interrograte the device for its I2C ID number, should be 0x60
+    uint8_t id;
+    read_registers(0xD0, &id, 1);
+    printf("Chip ID is 0x%x\n", id);
+
+    read_compensation_parameters();
+
+    write_register(0xF2, 0x1); // Humidity oversampling register - going for x1
+    write_register(0xF4, 0x27);// Set rest of oversampling modes and run mode to normal
+
+    int32_t humidity, pressure, temperature;
+
+    while (1) {
+        bme280_read_raw(&humidity, &pressure, &temperature);
+
+        // These are the raw numbers from the chip, so we need to run through the
+        // compensations to get human understandable numbers
+        pressure = compensate_pressure(pressure);
+        temperature = compensate_temp(temperature);
+        humidity = compensate_humidity(humidity);
+
+        printf("Humidity = %.2f%%\n", humidity / 1024.0);
+        printf("Pressure = %dPa\n", pressure);
+        printf("Temp. = %.2fC\n", temperature / 100.0);
+
+        sleep_ms(1000);
+    }
+
+    return 0;
+}