\(I^2C\) sběrnice pohledem programátora

uint i2c_init( i2c_inst_t *i2c, uint baudrate );
void i2c_deinit( i2c_inst_t *i2c );

static uint i2c_hw_index(i2c_inst_t *i2c);

uint i2c_set_baudrate( i2c_inst_t *i2c, uint baudrate );

void i2c_set_slave_mode( i2c_inst_t *i2c, bool slave, uint8_t addr );

int i2c_write_blocking( i2c_inst_t *i2c, uint8_t addr, const uint8_t *src, size_t len, bool nostop );

int i2c_write_timeout_us( i2c_inst_t *i2c, uint8_t addr, const uint8_t *src, size_t len, bool nostop, uint timeout_us ); (1)
int i2c_write_blocking_until( i2c_inst_t *i2c, uint8_t addr, const uint8_t *src, size_t len, bool nostop, absolute_time_t until ); (2)

static size_t i2c_get_write_available( i2c_inst_t *i2c );

static void i2c_write_raw_blocking( i2c_inst_t *i2c, const uint8_t *src, size_t len );

/**
 * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

// Proskenujeme všechny 7-bit I2C adresy, abychom zjistili, zda se někde nenachází
// nějaké podřízené zařízení. Tabulka bude vypadat takto:
//
// I2C Bus Scan
//    0 1 2 3 4 5 6 7 8 9 A B C D E F
// 00 . . . . . . . . . . . . . . . .
// 10 . . @ . . . . . . . . . . . . .
// 20 . . . . . . . . . . . . . . . .
// 30 . . . . @ . . . . . . . . . . .
// 40 . . . . . . . . . . . . . . . .
// 50 . . . . . . . . . . . . . . . .
// 60 . . . . . . . . . . . . . . . .
// 70 . . . . . . . . . . . . . . . .
// T.j. na adresách 0x12 a 0x34 něco je.

#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/binary_info.h"
#include "hardware/i2c.h"

#define I2C		        i2c1        (1)
#define PIN_SDA         14          (2)
#define PIN_SCL         15          (3)

// I2C rezervuje některé adresy pro speciální účely. Vynecháme je ze skenování.
// Rezervované adresy jsou ve formě 000 0xxx nebo 111 1xxx
bool reserved_addr(uint8_t addr) {
    return (addr & 0x78) == 0 || (addr & 0x78) == 0x78;
}

int main() {
    // Zapneme UART, abychom mohli tisknout na standardní výstup
    stdio_init_all();

    getchar(); (4)

    i2c_init(I2C, 100 * 1000);
    gpio_set_function(PIN_SDA, GPIO_FUNC_I2C);
    gpio_set_function(PIN_SCL, GPIO_FUNC_I2C);
    gpio_pull_up(PIN_SDA); (5)
    gpio_pull_up(PIN_SCL); (6)

    printf("\nI2C Bus Scan\n");
    printf("   0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F\n");

    for (int addr = 0; addr < (1 << 7); ++addr) {
        if (addr % 16 == 0) {
            printf("%02x ", addr);
        }

        // Uděláme 1 bajtové čtení z testované adresy. Pokud podřízené zařízení
        // pošle potvrzení z této adresy, funkce i2c_read_blocking vrátí počet
        // přečtených bajtů. Jestliže se na adrese nic nenachází funkce vrátí -1.

        int ret;
        uint8_t rxdata;
        if (reserved_addr(addr)) // Přeskočíme rezervované adresy.
            ret = PICO_ERROR_GENERIC;
        else
            ret = i2c_read_blocking(I2C, addr, &rxdata, 1, false);

        printf(ret < 0 ? "." : "@");
        printf(addr % 16 == 15 ? "\n" : "  ");
    }
    printf("Hotovo.\n");
    return 0;
}

Vítejte v programu minicom 2.9

VOLBY: I18n
Port /dev/ttyACM0, 14:14:42

Stiskněte CTRL-A Z pro nápovědu o klávesách se zvláštním významem


I2C Bus Scan
   0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
00 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
10 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
20 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
30 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
40 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
50 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
60 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
70 .  .  .  .  .  .  @  .  .  .  .  .  .  .  .  .
Done.

#include <stdio.h>

#include "hardware/i2c.h"
#include "pico/binary_info.h"
#include "pico/stdlib.h"

// kterou i2c budeme používat
#define I2C             i2c0
// piny
#define PIN_SDA         14          (2)
#define PIN_SCL         15          (3)

// BMP280 má I2C adresu 0x76
#define ADDR _u(0x76)

// hardwarové registry
#define REG_CONFIG      _u(0xF5)
#define REG_CTRL_MEAS   _u(0xF4)
#define REG_RESET       _u(0xE0)
#define REG_CHIP_ID     _u(0xD0)

// teplota
#define REG_TEMP_XLSB   _u(0xFC)
#define REG_TEMP_LSB    _u(0xFB)
#define REG_TEMP_MSB    _u(0xFA)

// tlak
#define REG_PRESSURE_XLSB   _u(0xF9)
#define REG_PRESSURE_LSB    _u(0xF8)
#define REG_PRESSURE_MSB    _u(0xF7)


void bmp280_reset()
{
    // reset zařízení
    uint8_t buf[2] = { REG_RESET, 0xB6 };
    i2c_write_blocking(I2C, ADDR, buf, 2, false);
}

uint8_t bmp280_read_chip_id()
{
    uint8_t buf[1] = { 0x0 };
    uint8_t reg = REG_CHIP_ID;

    i2c_write_blocking(I2C, ADDR, &reg, 1, true);  // true - přidržíme sběrnici, chceme hned číst
    i2c_read_blocking(I2C, ADDR, buf, 1, false);  // false - uvolním sběrnici

    return buf[0];
}

int main( void )
{
    i2c_init(I2C, 100 * 1000);
    gpio_set_function(PIN_SDA, GPIO_FUNC_I2C);
    gpio_set_function(PIN_SCL, GPIO_FUNC_I2C);
    gpio_pull_up(PIN_SDA);
    gpio_pull_up(PIN_SCL);
    bmp280_reset();
    sleep_ms(20);
    printf("BMP280 ma identifikator %#u\n", bmp280_read_chip_id() );
}

BM280 ma identifikator chipu: 0x58

/**
 * Měření teploty a tlaku
 *
 * SPDX-License-Identifier: BSD-3-Clause
 **/

#include <stdio.h>

#include "hardware/i2c.h"
#include "pico/binary_info.h"
#include "pico/stdlib.h"

#include "ssd1306.h"
#include "font_spleen_16x8a.h"

// display
#define DISPLAY_WIDTH 128
#define DISPLAY_HEIGHT 32
#define OLED_ADDR 0x3C
#define I2C_FREQ 400000
#define SLEEPTIME 55
#define DISPL_PIN_SDA 18            // piny pro dispej
#define DISPL_PIN_SCL 19

 // BMP280 má I2C adresu 0x76
#define ADDR _u(0x76)
// kterou i2c budeme používat
#define I2C             i2c0
// piny
#define PIN_SDA         4          // piny pro čidlo BM280
#define PIN_SCL         5          //

// hardware registry
#define REG_CONFIG      _u(0xF5)
#define REG_CTRL_MEAS   _u(0xF4)
#define REG_RESET       _u(0xE0)

#define REG_TEMP_XLSB   _u(0xFC)
#define REG_TEMP_LSB    _u(0xFB)
#define REG_TEMP_MSB    _u(0xFA)

#define REG_PRESSURE_XLSB   _u(0xF9)
#define REG_PRESSURE_LSB    _u(0xF8)
#define REG_PRESSURE_MSB    _u(0xF7)

// kalibrační registry
#define REG_DIG_T1_LSB _u(0x88)
#define REG_DIG_T1_MSB _u(0x89)
#define REG_DIG_T2_LSB _u(0x8A)
#define REG_DIG_T2_MSB _u(0x8B)
#define REG_DIG_T3_LSB _u(0x8C)
#define REG_DIG_T3_MSB _u(0x8D)
#define REG_DIG_P1_LSB _u(0x8E)
#define REG_DIG_P1_MSB _u(0x8F)
#define REG_DIG_P2_LSB _u(0x90)
#define REG_DIG_P2_MSB _u(0x91)
#define REG_DIG_P3_LSB _u(0x92)
#define REG_DIG_P3_MSB _u(0x93)
#define REG_DIG_P4_LSB _u(0x94)
#define REG_DIG_P4_MSB _u(0x95)
#define REG_DIG_P5_LSB _u(0x96)
#define REG_DIG_P5_MSB _u(0x97)
#define REG_DIG_P6_LSB _u(0x98)
#define REG_DIG_P6_MSB _u(0x99)
#define REG_DIG_P7_LSB _u(0x9A)
#define REG_DIG_P7_MSB _u(0x9B)
#define REG_DIG_P8_LSB _u(0x9C)
#define REG_DIG_P8_MSB _u(0x9D)
#define REG_DIG_P9_LSB _u(0x9E)
#define REG_DIG_P9_MSB _u(0x9F)

// počet kalibračních registrů
#define NUM_CALIB_PARAMS 24

struct bmp280_calib_param {
    // temperature params
    uint16_t dig_t1;
    int16_t dig_t2;
    int16_t dig_t3;

    // pressure params
    uint16_t dig_p1;
    int16_t dig_p2;
    int16_t dig_p3;
    int16_t dig_p4;
    int16_t dig_p5;
    int16_t dig_p6;
    int16_t dig_p7;
    int16_t dig_p8;
    int16_t dig_p9;
};

void bmp280_init() {
    // use the "handheld device dynamic" optimal setting (see datasheet)
    uint8_t buf[2];

    // 500ms sampling time, x16 filter
    const uint8_t reg_config_val = ((0x04 << 5) | (0x05 << 2)) & 0xFC;

    // send register number followed by its corresponding value
    buf[0] = REG_CONFIG;
    buf[1] = reg_config_val;
    i2c_write_blocking(I2C, ADDR, buf, 2, false);

    // osrs_t x1, osrs_p x4, normal mode operation
    const uint8_t reg_ctrl_meas_val = (0x01 << 5) | (0x03 << 2) | (0x03);
    buf[0] = REG_CTRL_MEAS;
    buf[1] = reg_ctrl_meas_val;
    i2c_write_blocking(I2C, ADDR, buf, 2, false);
}

void bmp280_read_raw(int32_t* temp, int32_t* pressure) {
    // BMP280 data registers are auto-incrementing and we have 3 temperature and
    // pressure registers each, so we start at 0xF7 and read 6 bytes to 0xFC
    // note: normal mode does not require further ctrl_meas and config register writes

    uint8_t buf[6];
    uint8_t reg = REG_PRESSURE_MSB;
    i2c_write_blocking(I2C, ADDR, &reg, 1, true);  // true to keep master control of bus
    i2c_read_blocking(I2C, ADDR, buf, 6, false);  // false - finished with bus

    // store the 20 bit read in a 32 bit signed integer for conversion
    *pressure = (buf[0] << 12) | (buf[1] << 4) | (buf[2] >> 4);
    *temp = (buf[3] << 12) | (buf[4] << 4) | (buf[5] >> 4);
}

void bmp280_reset() {
    // reset the device with the power-on-reset procedure
    uint8_t buf[2] = { REG_RESET, 0xB6 };
    i2c_write_blocking(I2C, ADDR, buf, 2, false);
}

// intermediate function that calculates the fine resolution temperature
// used for both pressure and temperature conversions
int32_t bmp280_convert(int32_t temp, struct bmp280_calib_param* params) {
    // use the 32-bit fixed point compensation implementation given in the
    // datasheet

    int32_t var1, var2;
    var1 = ((((temp >> 3) - ((int32_t)params->dig_t1 << 1))) * ((int32_t)params->dig_t2)) >> 11;
    var2 = (((((temp >> 4) - ((int32_t)params->dig_t1)) * ((temp >> 4) - ((int32_t)params->dig_t1))) >> 12) * ((int32_t)params->dig_t3)) >> 14;
    return var1 + var2;
}

int32_t bmp280_convert_temp(int32_t temp, struct bmp280_calib_param* params) {
    // uses the BMP280 calibration parameters to compensate the temperature value read from its registers
    int32_t t_fine = bmp280_convert(temp, params);
    return (t_fine * 5 + 128) >> 8;
}

int32_t bmp280_convert_pressure(int32_t pressure, int32_t temp, struct bmp280_calib_param* params) {
    // uses the BMP280 calibration parameters to compensate the pressure value read from its registers

    int32_t t_fine = bmp280_convert(temp, params);

    int32_t var1, var2;
    uint32_t converted = 0.0;
    var1 = (((int32_t)t_fine) >> 1) - (int32_t)64000;
    var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((int32_t)params->dig_p6);
    var2 += ((var1 * ((int32_t)params->dig_p5)) << 1);
    var2 = (var2 >> 2) + (((int32_t)params->dig_p4) << 16);
    var1 = (((params->dig_p3 * (((var1 >> 2) * (var1 >> 2)) >> 13)) >> 3) + ((((int32_t)params->dig_p2) * var1) >> 1)) >> 18;
    var1 = ((((32768 + var1)) * ((int32_t)params->dig_p1)) >> 15);
    if (var1 == 0) {
        return 0;  // avoid exception caused by division by zero
    }
    converted = (((uint32_t)(((int32_t)1048576) - pressure) - (var2 >> 12))) * 3125;
    if (converted < 0x80000000) {
        converted = (converted << 1) / ((uint32_t)var1);
    } else {
        converted = (converted / (uint32_t)var1) * 2;
    }
    var1 = (((int32_t)params->dig_p9) * ((int32_t)(((converted >> 3) * (converted >> 3)) >> 13))) >> 12;
    var2 = (((int32_t)(converted >> 2)) * ((int32_t)params->dig_p8)) >> 13;
    converted = (uint32_t)((int32_t)converted + ((var1 + var2 + params->dig_p7) >> 4));
    return converted;
}

void bmp280_get_calib_params(struct bmp280_calib_param* params) {
    // raw temp and pressure values need to be calibrated according to
    // parameters generated during the manufacturing of the sensor
    // there are 3 temperature params, and 9 pressure params, each with a LSB
    // and MSB register, so we read from 24 registers

    uint8_t buf[NUM_CALIB_PARAMS] = { 0 };
    uint8_t reg = REG_DIG_T1_LSB;
    i2c_write_blocking(I2C, ADDR, &reg, 1, true);  // true to keep master control of bus
    // read in one go as register addresses auto-increment
    i2c_read_blocking(I2C, ADDR, buf, NUM_CALIB_PARAMS, false);  // false, we're done reading

    // store these in a struct for later use
    params->dig_t1 = (uint16_t)(buf[1] << 8) | buf[0];
    params->dig_t2 = (int16_t)(buf[3] << 8) | buf[2];
    params->dig_t3 = (int16_t)(buf[5] << 8) | buf[4];

    params->dig_p1 = (uint16_t)(buf[7] << 8) | buf[6];
    params->dig_p2 = (int16_t)(buf[9] << 8) | buf[8];
    params->dig_p3 = (int16_t)(buf[11] << 8) | buf[10];
    params->dig_p4 = (int16_t)(buf[13] << 8) | buf[12];
    params->dig_p5 = (int16_t)(buf[15] << 8) | buf[14];
    params->dig_p6 = (int16_t)(buf[17] << 8) | buf[16];
    params->dig_p7 = (int16_t)(buf[19] << 8) | buf[18];
    params->dig_p8 = (int16_t)(buf[21] << 8) | buf[20];
    params->dig_p9 = (int16_t)(buf[23] << 8) | buf[22];
}

int main() {
    char displ_str1[64];
    char displ_str2[64];

    stdio_init_all();

    // i2c pro čidlo
    i2c_init(I2C, 100 * 1000);
    gpio_set_function(PIN_SDA, GPIO_FUNC_I2C);
    gpio_set_function(PIN_SCL, GPIO_FUNC_I2C);
    gpio_pull_up(PIN_SDA);
    gpio_pull_up(PIN_SCL);

    // i2c pro displej
    i2c_init(i2c1, 100 * 400);
    gpio_set_function(DISPL_PIN_SDA, GPIO_FUNC_I2C);
    gpio_set_function(DISPL_PIN_SCL, GPIO_FUNC_I2C);
    gpio_pull_up(DISPL_PIN_SDA);
    gpio_pull_up(DISPL_PIN_SCL);

    // konfigurace BMP280
    bmp280_init();

    // konfigurace OLED displeje
    ssd1306_t disp;
    disp.external_vcc = false;
    ssd1306_init(&disp, DISPLAY_WIDTH, DISPLAY_HEIGHT, OLED_ADDR, i2c1);
    ssd1306_clear(&disp);


    // kompenzační parametry z čidla
    struct bmp280_calib_param params;
    bmp280_get_calib_params(&params);

    int32_t raw_temperature;
    int32_t raw_pressure;

    sleep_ms(250); // počkáme, abychom nerozbili měření

    while (1) {
        bmp280_read_raw(&raw_temperature, &raw_pressure);
        int32_t temperature = bmp280_convert_temp(raw_temperature, &params);
        int32_t pressure = bmp280_convert_pressure(raw_pressure, raw_temperature, &params);
        printf("Atmosférický tlak = %.3f hPa\n", pressure / 100.f);
        printf("Teplota = %.2f ˚C\n", temperature / 100.f);
        for(int i=0; i<64; i++) {
            displ_str1[i]='\0'; displ_str2[i]='\0';
        }
        sprintf(displ_str1,"At:%.3f hPa", pressure / 100.f);
        sprintf(displ_str2,"Tepl:%.2f %cC", temperature / 100.f, 0xb0);
        ssd1306_clear(&disp);
        ssd1306_draw_string_with_font(&disp, 0,  0, 1, font_spleen_16x8a, displ_str1);
        ssd1306_draw_string_with_font(&disp, 0, 16, 1, font_spleen_16x8a, displ_str2);
        ssd1306_show(&disp);

        // budeme číst data každých 5 sekund
        sleep_ms(5000);
    }
}