mirror
/
pimoroni-pico
kopia lustrzana https://github.com/pimoroni/pimoroni-pico
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Add common I2C class 

This change adds a common I2C class, gathering various I2C functions into a single point of responsibility.

It's necessary for correctly managing the I2C bus pins and state across multiple devices.
pull/129/head
Phil Howard 2021-05-14 18:12:37 +01:00
rodzic 3dfae2ed5c
commit 42c7555c96
58 zmienionych plików z 484 dodań i 440 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

1
CMakeLists.txt
Wyświetl plik

@ -32,6 +32,7 @@ include_directories(
${CMAKE_CURRENT_LIST_DIR}
)
add_subdirectory(common)
add_subdirectory(drivers)
add_subdirectory(libraries)

9
common/CMakeLists.txt 100644
Wyświetl plik

@ -0,0 +1,9 @@
add_library(pimoroni_i2c INTERFACE)
target_sources(pimoroni_i2c INTERFACE
${CMAKE_CURRENT_LIST_DIR}/pimoroni_i2c.cpp)
target_include_directories(pimoroni_i2c INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(pimoroni_i2c INTERFACE pico_stdlib)

5
common/pimoroni.hpp → common/pimoroni_common.hpp
Wyświetl plik

@ -32,4 +32,9 @@ namespace pimoroni {
BG_SPI_FRONT,
BG_SPI_BACK
};
enum BOARD {
BREAKOUT_GARDEN,
PICO_EXPLORER
};
}

77
common/pimoroni_i2c.cpp 100644
Wyświetl plik

@ -0,0 +1,77 @@
#include "pimoroni_common.hpp"
#include "pimoroni_i2c.hpp"
namespace pimoroni {
void I2C::init() {
i2c = ((sda / 2) & 0b1) ? i2c1 : i2c0;
i2c_init(i2c, 400000);
gpio_set_function(sda, GPIO_FUNC_I2C); gpio_pull_up(sda);
gpio_set_function(scl, GPIO_FUNC_I2C); gpio_pull_up(scl);
}
/* Basic wrappers for devices using i2c functions directly */
int I2C::write_blocking(uint8_t addr, const uint8_t *src, size_t len, bool nostop) {
return i2c_write_blocking(i2c, addr, src, len, nostop);
}
int I2C::read_blocking(uint8_t addr, uint8_t *dst, size_t len, bool nostop) {
return i2c_read_blocking(i2c, addr, dst, len, nostop);
}
/* Convenience functions for various common i2c operations */
void I2C::reg_write_uint8(uint8_t address, uint8_t reg, uint8_t value) {
uint8_t buffer[2] = {reg, value};
i2c_write_blocking(i2c, address, buffer, 2, false);
}
uint8_t I2C::reg_read_uint8(uint8_t address, uint8_t reg) {
uint8_t value;
i2c_write_blocking(i2c, address, &reg, 1, false);
i2c_read_blocking(i2c, address, (uint8_t *)&value, 1, false);
return value;
}
int I2C::write_bytes(uint8_t address, uint8_t reg, uint8_t *buf, int len) {
uint8_t buffer[len + 1];
buffer[0] = reg;
for(int x = 0; x < len; x++) {
buffer[x + 1] = buf[x];
}
return i2c_write_blocking(i2c, address, buffer, len + 1, false);
};
int I2C::read_bytes(uint8_t address, uint8_t reg, uint8_t *buf, int len) {
i2c_write_blocking(i2c, address, &reg, 1, true);
i2c_read_blocking(i2c, address, buf, len, false);
return len;
};
uint8_t I2C::get_bits(uint8_t address, uint8_t reg, uint8_t shift, uint8_t mask) {
uint8_t value;
read_bytes(address, reg, &value, 1);
return value & (mask << shift);
}
void I2C::set_bits(uint8_t address, uint8_t reg, uint8_t shift, uint8_t mask) {
uint8_t value;
read_bytes(address, reg, &value, 1);
value |= mask << shift;
write_bytes(address, reg, &value, 1);
}
void I2C::clear_bits(uint8_t address, uint8_t reg, uint8_t shift, uint8_t mask) {
uint8_t value;
read_bytes(address, reg, &value, 1);
value &= ~(mask << shift);
write_bytes(address, reg, &value, 1);
}
int16_t I2C::reg_read_int16(uint8_t address, uint8_t reg) {
int16_t value;
i2c_write_blocking(i2c, address, &reg, 1, true);
i2c_read_blocking(i2c, address, (uint8_t *)&value, 2, false);
return value;
}
}

66
common/pimoroni_i2c.hpp 100644
Wyświetl plik

@ -0,0 +1,66 @@
#pragma once
#include <stdint.h>
#include <climits>
#include "hardware/i2c.h"
#include "hardware/gpio.h"
#include "pimoroni_common.hpp"
#include "pimoroni_i2c.hpp"
namespace pimoroni {
class I2C {
private:
i2c_inst_t *i2c = PIMORONI_I2C_DEFAULT_INSTANCE;
uint sda = I2C_DEFAULT_SDA;
uint scl = I2C_DEFAULT_SCL;
uint interrupt = PIN_UNUSED;
public:
I2C(BOARD board) {
switch(board) {
case BREAKOUT_GARDEN:
sda = I2C_BG_SDA;
scl = I2C_BG_SCL;
interrupt = I2C_BG_INT;
break;
case PICO_EXPLORER:
default:
sda = I2C_DEFAULT_SDA;
scl = I2C_DEFAULT_SCL;
interrupt = I2C_DEFAULT_INT;
break;
}
init();
}
I2C(uint sda, uint scl) : sda(sda), scl(scl) {
init();
}
~I2C() {
i2c_deinit(i2c);
gpio_disable_pulls(sda);
gpio_set_function(sda, GPIO_FUNC_NULL);
gpio_disable_pulls(scl);
gpio_set_function(scl, GPIO_FUNC_NULL);
}
void reg_write_uint8(uint8_t address, uint8_t reg, uint8_t value);
uint8_t reg_read_uint8(uint8_t address, uint8_t reg);
int16_t reg_read_int16(uint8_t address, uint8_t reg);
int write_bytes(uint8_t address, uint8_t reg, uint8_t *buf, int len);
int read_bytes(uint8_t address, uint8_t reg, uint8_t *buf, int len);
uint8_t get_bits(uint8_t address, uint8_t reg, uint8_t shift, uint8_t mask=0b1);
void set_bits(uint8_t address, uint8_t reg, uint8_t shift, uint8_t mask=0b1);
void clear_bits(uint8_t address, uint8_t reg, uint8_t shift, uint8_t mask=0b1);
int write_blocking(uint8_t addr, const uint8_t *src, size_t len, bool nostop);
int read_blocking(uint8_t addr, uint8_t *dst, size_t len, bool nostop);
i2c_inst_t* get_i2c() {return i2c;}
uint get_scl() {return scl;}
uint get_sda() {return sda;}
private:
void init();
};
}

2
drivers/as7262/as7262.cmake
Wyświetl plik

@ -7,4 +7,4 @@ target_sources(${DRIVER_NAME} INTERFACE
target_include_directories(${DRIVER_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c)
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c pimoroni_i2c)

19
drivers/as7262/as7262.cpp
Wyświetl plik

@ -42,13 +42,6 @@ namespace pimoroni {
bool AS7262::init() {
bool succeeded = false;
i2c_init(i2c, 400000);
gpio_set_function(sda, GPIO_FUNC_I2C);
gpio_pull_up(sda);
gpio_set_function(scl, GPIO_FUNC_I2C);
gpio_pull_up(scl);
if(interrupt != PIN_UNUSED) {
gpio_set_function(interrupt, GPIO_FUNC_SIO);
gpio_set_dir(interrupt, GPIO_IN);
@ -71,15 +64,15 @@ namespace pimoroni {
}
i2c_inst_t* AS7262::get_i2c() const {
return i2c;
return i2c->get_i2c();
}
int AS7262::get_sda() const {
return sda;
return i2c->get_sda();
}
int AS7262::get_scl() const {
return scl;
return i2c->get_scl();
}
int AS7262::get_int() const {
@ -216,13 +209,13 @@ namespace pimoroni {
// Plumbing for virtual i2c
void AS7262::_i2c_reg_write_uint8(uint8_t reg, uint8_t value) {
uint8_t buffer[2] = {reg, value};
i2c_write_blocking(i2c, address, buffer, 2, false);
i2c->write_blocking(address, buffer, 2, false);
}
uint8_t AS7262::_i2c_reg_read_uint8(uint8_t reg) {
uint8_t value;
i2c_write_blocking(i2c, address, &reg, 1, false);
i2c_read_blocking(i2c, address, (uint8_t *)&value, 1, false);
i2c->write_blocking(address, &reg, 1, false);
i2c->read_blocking(address, (uint8_t *)&value, 1, false);
return value;
}
}

21
drivers/as7262/as7262.hpp
Wyświetl plik

@ -4,6 +4,8 @@
#include "hardware/i2c.h"
#include "hardware/gpio.h"
#include "common/pimoroni_common.hpp"
#include "common/pimoroni_i2c.hpp"
namespace pimoroni {
@ -70,12 +72,10 @@ namespace pimoroni {
// Variables
//--------------------------------------------------
private:
i2c_inst_t *i2c = i2c0;
I2C *i2c;
// interface pins with our standard defaults where appropriate
int8_t address = DEFAULT_I2C_ADDRESS;
int8_t sda = DEFAULT_SDA_PIN;
int8_t scl = DEFAULT_SCL_PIN;
int8_t interrupt = DEFAULT_INT_PIN;
@ -83,10 +83,17 @@ namespace pimoroni {
// Constructors/Destructor
//--------------------------------------------------
public:
AS7262() {}
AS7262(i2c_inst_t *i2c, uint8_t sda, uint8_t scl, uint8_t interrupt = PIN_UNUSED) :
i2c(i2c), sda(sda), scl(scl), interrupt(interrupt) {}
AS7262() {
i2c = new I2C(DEFAULT_SDA_PIN, DEFAULT_SCL_PIN);
};
AS7262(uint8_t address) : address(address) {
i2c = new I2C(DEFAULT_SDA_PIN, DEFAULT_SCL_PIN);
};
AS7262(i2c_inst_t *i2c_inst, uint8_t address, uint sda, uint scl, uint8_t interrupt = PIN_UNUSED) : address(address), interrupt(interrupt) {
i2c = new I2C(sda, scl);
}
AS7262(I2C *i2c, uint8_t address = DEFAULT_I2C_ADDRESS, uint8_t interrupt = PIN_UNUSED) :
i2c(i2c), address(address), interrupt(interrupt) {}
//--------------------------------------------------

2
drivers/ioexpander/ioexpander.cmake
Wyświetl plik

@ -7,4 +7,4 @@ target_sources(${DRIVER_NAME} INTERFACE
target_include_directories(${DRIVER_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c)
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c pimoroni_i2c)

98
drivers/ioexpander/ioexpander.cpp
Wyświetl plik

@ -298,15 +298,20 @@ namespace pimoroni {
}
IOExpander::IOExpander() :
IOExpander(i2c0, DEFAULT_I2C_ADDRESS, DEFAULT_SDA_PIN, DEFAULT_SCL_PIN, DEFAULT_INT_PIN) {
}
IOExpander(new I2C(DEFAULT_SDA_PIN, DEFAULT_SCL_PIN), DEFAULT_I2C_ADDRESS, DEFAULT_INT_PIN, timeout, debug) {};
IOExpander::IOExpander(uint8_t address, uint32_t timeout, bool debug) :
IOExpander(i2c0, address, DEFAULT_SDA_PIN, DEFAULT_SCL_PIN, DEFAULT_INT_PIN, timeout, debug) {
}
IOExpander(new I2C(DEFAULT_SDA_PIN, DEFAULT_SCL_PIN), address, DEFAULT_INT_PIN, timeout, debug) {};
IOExpander::IOExpander(uint8_t address, uint8_t sda, uint8_t scl, uint8_t interrupt, uint32_t timeout, bool debug) :
IOExpander(new I2C(sda, scl), address, interrupt, timeout, debug) {};
IOExpander::IOExpander(i2c_inst_t *i2c, uint8_t address, uint8_t sda, uint8_t scl, uint8_t interrupt, uint32_t timeout, bool debug) :
i2c(i2c), address(address), sda(sda), scl(scl), interrupt(interrupt),
IOExpander(new I2C(sda, scl), address, interrupt, timeout, debug) {};
IOExpander::IOExpander(I2C *i2c, uint8_t address, uint8_t interrupt, uint32_t timeout, bool debug) :
i2c(i2c),
address(address), interrupt(interrupt),
timeout(timeout), debug(debug), vref(3.3f),
encoder_offset{0,0,0,0},
encoder_last{0,0,0,0},
@ -323,17 +328,12 @@ namespace pimoroni {
Pin::adc(0, 6, 3),
Pin::adc_or_pwm(0, 5, 4, 2, reg::PIOCON1),
Pin::adc(0, 7, 2),
Pin::adc(1, 7, 0)} {
}
Pin::adc(1, 7, 0)}
{}
bool IOExpander::init(bool skipChipIdCheck) {
bool succeeded = true;
i2c_init(i2c, 400000);
gpio_set_function(sda, GPIO_FUNC_I2C); gpio_pull_up(sda);
gpio_set_function(scl, GPIO_FUNC_I2C); gpio_pull_up(scl);
if(interrupt != PIN_UNUSED) {
gpio_set_function(interrupt, GPIO_FUNC_SIO);
gpio_set_dir(interrupt, GPIO_IN);
@ -356,7 +356,7 @@ namespace pimoroni {
}
i2c_inst_t* IOExpander::get_i2c() const {
return i2c;
return i2c->get_i2c();
}
int IOExpander::get_address() const {
@ -364,11 +364,11 @@ namespace pimoroni {
}
int IOExpander::get_sda() const {
return sda;
return i2c->get_sda();
}
int IOExpander::get_scl() const {
return scl;
return i2c->get_scl();
}
int IOExpander::get_int() const {
@ -376,12 +376,12 @@ namespace pimoroni {
}
uint16_t IOExpander::get_chip_id() {
return ((uint16_t)i2c_reg_read_uint8(reg::CHIP_ID_H) << 8) | (uint16_t)i2c_reg_read_uint8(reg::CHIP_ID_L);
return ((uint16_t)i2c->reg_read_uint8(address, reg::CHIP_ID_H) << 8) | (uint16_t)i2c->reg_read_uint8(address, reg::CHIP_ID_L);
}
void IOExpander::set_address(uint8_t address) {
set_bit(reg::CTRL, 4);
i2c_reg_write_uint8(reg::ADDR, address);
i2c->reg_write_uint8(address, reg::ADDR, address);
this->address = address;
sleep_ms(250); //TODO Handle addr change IOError better
//wait_for_flash()
@ -496,7 +496,7 @@ namespace pimoroni {
// PWMTYP - PWM type select: 0 edge-aligned, 1 center-aligned
// FBINEN - Fault-break input enable
i2c_reg_write_uint8(reg::PWMCON1, pwmdiv2);
i2c->reg_write_uint8(address, reg::PWMCON1, pwmdiv2);
}
return divider_good;
@ -504,8 +504,8 @@ namespace pimoroni {
void IOExpander::set_pwm_period(uint16_t value, bool load) {
value &= 0xffff;
i2c_reg_write_uint8(reg::PWMPL, (uint8_t)(value & 0xff));
i2c_reg_write_uint8(reg::PWMPH, (uint8_t)(value >> 8));
i2c->reg_write_uint8(address, reg::PWMPL, (uint8_t)(value & 0xff));
i2c->reg_write_uint8(address, reg::PWMPH, (uint8_t)(value >> 8));
if(load)
pwm_load();
@ -561,8 +561,8 @@ namespace pimoroni {
clr_bit(io_pin.reg_io_pwm, io_pin.pwm_channel);
}
uint8_t pm1 = i2c_reg_read_uint8(io_pin.reg_m1);
uint8_t pm2 = i2c_reg_read_uint8(io_pin.reg_m2);
uint8_t pm1 = i2c->reg_read_uint8(address, io_pin.reg_m1);
uint8_t pm2 = i2c->reg_read_uint8(address, io_pin.reg_m2);
// Clear the pm1 and pm2 bits
pm1 &= 255 - (1 << io_pin.pin);
@ -572,15 +572,15 @@ namespace pimoroni {
pm1 |= (gpio_mode >> 1) << io_pin.pin;
pm2 |= (gpio_mode & 0b1) << io_pin.pin;
i2c_reg_write_uint8(io_pin.reg_m1, pm1);
i2c_reg_write_uint8(io_pin.reg_m2, pm2);
i2c->reg_write_uint8(address, io_pin.reg_m1, pm1);
i2c->reg_write_uint8(address, io_pin.reg_m2, pm2);
// Set up Schmitt trigger mode on inputs
if(mode == PIN_MODE_PU || mode == PIN_MODE_IN)
change_bit(io_pin.reg_ps, io_pin.pin, schmitt_trigger);
// 5th bit of mode encodes default output pin state
i2c_reg_write_uint8(io_pin.reg_p, (initial_state << 3) | io_pin.pin);
i2c->reg_write_uint8(address, io_pin.reg_p, (initial_state << 3) | io_pin.pin);
}
int16_t IOExpander::input(uint8_t pin, uint32_t adc_timeout) {
@ -599,7 +599,7 @@ namespace pimoroni {
clr_bits(reg::ADCCON0, 0x0f);
set_bits(reg::ADCCON0, io_pin.adc_channel);
i2c_reg_write_uint8(reg::AINDIDS, 0);
i2c->reg_write_uint8(address, reg::AINDIDS, 0);
set_bit(reg::AINDIDS, io_pin.adc_channel);
set_bit(reg::ADCCON1, 0);
@ -617,8 +617,8 @@ namespace pimoroni {
}
}
uint8_t hi = i2c_reg_read_uint8(reg::ADCRH);
uint8_t lo = i2c_reg_read_uint8(reg::ADCRL);
uint8_t hi = i2c->reg_read_uint8(address, reg::ADCRH);
uint8_t lo = i2c->reg_read_uint8(address, reg::ADCRL);
return (uint16_t)(hi << 4) | (uint16_t)lo;
}
else {
@ -647,7 +647,7 @@ namespace pimoroni {
clr_bits(reg::ADCCON0, 0x0f);
set_bits(reg::ADCCON0, io_pin.adc_channel);
i2c_reg_write_uint8(reg::AINDIDS, 0);
i2c->reg_write_uint8(address, reg::AINDIDS, 0);
set_bit(reg::AINDIDS, io_pin.adc_channel);
set_bit(reg::ADCCON1, 0);
@ -666,8 +666,8 @@ namespace pimoroni {
}
}
uint8_t hi = i2c_reg_read_uint8(reg::ADCRH);
uint8_t lo = i2c_reg_read_uint8(reg::ADCRL);
uint8_t hi = i2c->reg_read_uint8(address, reg::ADCRH);
uint8_t lo = i2c->reg_read_uint8(address, reg::ADCRL);
return ((float)((uint16_t)(hi << 4) | (uint16_t)lo) / 4095.0f) * vref;
}
else {
@ -693,8 +693,8 @@ namespace pimoroni {
printf("Outputting PWM to pin: %d\n", pin);
}
i2c_reg_write_uint8(io_pin.reg_pwml, (uint8_t)(value & 0xff));
i2c_reg_write_uint8(io_pin.reg_pwmh, (uint8_t)(value >> 8));
i2c->reg_write_uint8(address, io_pin.reg_pwml, (uint8_t)(value & 0xff));
i2c->reg_write_uint8(address, io_pin.reg_pwmh, (uint8_t)(value >> 8));
if(load)
pwm_load();
}
@ -726,20 +726,20 @@ namespace pimoroni {
output(pin_c, 0);
}
i2c_reg_write_uint8(ENC_CFG[channel], pin_a | (pin_b << 4));
i2c->reg_write_uint8(address, ENC_CFG[channel], pin_a | (pin_b << 4));
change_bit(reg::ENC_EN, (channel * 2) + 1, count_microsteps);
set_bit(reg::ENC_EN, channel * 2);
// Reset internal encoder count to zero
uint8_t reg = ENC_COUNT[channel];
i2c_reg_write_uint8(reg, 0x00);
i2c->reg_write_uint8(address, reg, 0x00);
}
int16_t IOExpander::read_rotary_encoder(uint8_t channel) {
channel -= 1;
int16_t last = encoder_last[channel];
uint8_t reg = ENC_COUNT[channel];
int16_t value = (int16_t)i2c_reg_read_uint8(reg);
int16_t value = (int16_t)i2c->reg_read_uint8(address, reg);
if(value & 0b10000000)
value -= 256;
@ -754,21 +754,9 @@ namespace pimoroni {
return encoder_offset[channel] + value;
}
uint8_t IOExpander::i2c_reg_read_uint8(uint8_t reg) {
uint8_t value;
i2c_write_blocking(i2c, address, &reg, 1, true);
i2c_read_blocking(i2c, address, (uint8_t *)&value, 1, false);
return value;
}
void IOExpander::i2c_reg_write_uint8(uint8_t reg, uint8_t value) {
uint8_t buffer[2] = {reg, value};
i2c_write_blocking(i2c, address, buffer, 2, false);
}
uint8_t IOExpander::get_bit(uint8_t reg, uint8_t bit) {
// Returns the specified bit (nth position from right) from a register
return i2c_reg_read_uint8(reg) & (1 << bit);
return i2c->reg_read_uint8(address, reg) & (1 << bit);
}
void IOExpander::set_bits(uint8_t reg, uint8_t bits) {
@ -780,7 +768,7 @@ namespace pimoroni {
if(BIT_ADDRESSED_REGS[i] == reg) {
for(uint8_t bit = 0; bit < 8; bit++) {
if(bits & (1 << bit))
i2c_reg_write_uint8(reg, 0b1000 | (bit & 0b111));
i2c->reg_write_uint8(address, reg, 0b1000 | (bit & 0b111));
}
reg_in_bit_addressed_regs = true;
break;
@ -789,9 +777,9 @@ namespace pimoroni {
// Now deal with any other registers
if(!reg_in_bit_addressed_regs) {
uint8_t value = i2c_reg_read_uint8(reg);
uint8_t value = i2c->reg_read_uint8(address, reg);
sleep_us(10);
i2c_reg_write_uint8(reg, value | bits);
i2c->reg_write_uint8(address, reg, value | bits);
}
}
@ -806,7 +794,7 @@ namespace pimoroni {
if(BIT_ADDRESSED_REGS[i] == reg) {
for(uint8_t bit = 0; bit < 8; bit++) {
if(bits & (1 << bit))
i2c_reg_write_uint8(reg, 0b0000 | (bit & 0b111));
i2c->reg_write_uint8(address, reg, 0b0000 | (bit & 0b111));
}
reg_in_bit_addressed_regs = true;
break;
@ -815,9 +803,9 @@ namespace pimoroni {
// Now deal with any other registers
if(!reg_in_bit_addressed_regs) {
uint8_t value = i2c_reg_read_uint8(reg);
uint8_t value = i2c->reg_read_uint8(address, reg);
sleep_us(10);
i2c_reg_write_uint8(reg, value & ~bits);
i2c->reg_write_uint8(address, reg, value & ~bits);
}
}

8
drivers/ioexpander/ioexpander.hpp
Wyświetl plik

@ -2,6 +2,8 @@
#include "hardware/i2c.h"
#include "hardware/gpio.h"
#include "common/pimoroni_common.hpp"
#include "common/pimoroni_i2c.hpp"
namespace pimoroni {
@ -142,12 +144,10 @@ namespace pimoroni {
// Variables
//--------------------------------------------------
private:
i2c_inst_t *i2c;
I2C *i2c;
// interface pins with our standard defaults where appropriate
int8_t address = DEFAULT_I2C_ADDRESS;
int8_t sda = DEFAULT_SDA_PIN;
int8_t scl = DEFAULT_SCL_PIN;
int8_t interrupt = DEFAULT_INT_PIN;
uint32_t timeout;
@ -164,7 +164,9 @@ namespace pimoroni {
public:
IOExpander();
IOExpander(uint8_t address, uint32_t timeout = 1, bool debug = false);
IOExpander(uint8_t address, uint8_t sda, uint8_t scl, uint8_t interrupt = PIN_UNUSED, uint32_t timeout = 1, bool debug = false);
IOExpander(i2c_inst_t *i2c, uint8_t address, uint8_t sda, uint8_t scl, uint8_t interrupt = PIN_UNUSED, uint32_t timeout = 1, bool debug = false);
IOExpander(I2C *i2c, uint8_t address=DEFAULT_I2C_ADDRESS, uint8_t interrupt = PIN_UNUSED, uint32_t timeout = 1, bool debug = false);
//--------------------------------------------------

2
drivers/is31fl3731/is31fl3731.cmake
Wyświetl plik

@ -7,4 +7,4 @@ target_sources(${DRIVER_NAME} INTERFACE
target_include_directories(${DRIVER_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c)
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c pimoroni_i2c)

44
drivers/is31fl3731/is31fl3731.cpp
Wyświetl plik

@ -54,28 +54,24 @@ namespace pimoroni {
};
bool IS31FL3731::init() {
i2c_init(i2c, 100000);
gpio_set_function(sda, GPIO_FUNC_I2C); gpio_pull_up(sda);
gpio_set_function(scl, GPIO_FUNC_I2C); gpio_pull_up(scl);
i2c_reg_write_uint8(reg::BANK, CONFIG_BANK);
i2c_reg_write_uint8(reg::SHUTDOWN, 0b00000000);
i2c->reg_write_uint8(address, reg::BANK, CONFIG_BANK);
i2c->reg_write_uint8(address, reg::SHUTDOWN, 0b00000000);
clear();
update(0);
i2c_reg_write_uint8(reg::SHUTDOWN, 0b00000001);
i2c->reg_write_uint8(address, reg::SHUTDOWN, 0b00000001);
i2c_reg_write_uint8(reg::MODE, mode::PICTURE);
i2c->reg_write_uint8(address, reg::MODE, mode::PICTURE);
i2c_reg_write_uint8(reg::AUDIOSYNC, 0);
i2c->reg_write_uint8(address, reg::AUDIOSYNC, 0);
return true;
}
i2c_inst_t* IS31FL3731::get_i2c() const {
return i2c;
return i2c->get_i2c();
}
int IS31FL3731::get_address() const {
@ -83,11 +79,11 @@ namespace pimoroni {
}
int IS31FL3731::get_sda() const {
return sda;
return i2c->get_sda();
}
int IS31FL3731::get_scl() const {
return scl;
return i2c->get_scl();
}
void IS31FL3731::clear() {
@ -96,20 +92,8 @@ namespace pimoroni {
}
}
void IS31FL3731::i2c_reg_write_uint8(uint8_t reg, uint8_t value) {
uint8_t buffer[2] = {reg, value};
i2c_write_blocking(i2c, address, buffer, 2, false);
}
int16_t IS31FL3731::i2c_reg_read_int16(uint8_t reg) {
int16_t value;
i2c_write_blocking(i2c, address, &reg, 1, true);
i2c_read_blocking(i2c, address, (uint8_t *)&value, 2, false);
return value;
}
void IS31FL3731::enable(std::initializer_list<uint8_t> pattern, uint8_t frame) {
i2c_reg_write_uint8(reg::BANK, frame);
i2c->reg_write_uint8(address, reg::BANK, frame);
uint8_t enable_buf[19];
enable_buf[0] = ENABLE_OFFSET;
uint8_t offset = 1;
@ -117,7 +101,7 @@ namespace pimoroni {
enable_buf[offset] = byte;
offset++;
}
i2c_write_blocking(i2c, address, enable_buf, sizeof(enable_buf), false);
i2c->write_blocking(address, enable_buf, sizeof(enable_buf), false);
}
void IS31FL3731::set(uint8_t index, uint8_t brightness) {
@ -125,10 +109,10 @@ namespace pimoroni {
}
void IS31FL3731::update(uint8_t frame) {
i2c_reg_write_uint8(reg::BANK, frame);
i2c->reg_write_uint8(address, reg::BANK, frame);
buf[0] = COLOR_OFFSET;
i2c_write_blocking(i2c, address, buf, sizeof(buf), false);
i2c_reg_write_uint8(reg::BANK, CONFIG_BANK); // Switch back to config bank
i2c_reg_write_uint8(reg::FRAME, frame); // Set the desired frame as active
i2c->write_blocking(address, buf, sizeof(buf), false);
i2c->reg_write_uint8(address, reg::BANK, CONFIG_BANK); // Switch back to config bank
i2c->reg_write_uint8(address, reg::FRAME, frame); // Set the desired frame as active
}
}

19
drivers/is31fl3731/is31fl3731.hpp
Wyświetl plik

@ -2,6 +2,8 @@
#include "hardware/i2c.h"
#include "hardware/gpio.h"
#include "common/pimoroni_common.hpp"
#include "common/pimoroni_i2c.hpp"
#include <initializer_list>
namespace pimoroni {
@ -15,20 +17,16 @@ namespace pimoroni {
static const uint8_t I2C_ADDRESS_ALTERNATE1 = 0x75;
static const uint8_t I2C_ADDRESS_ALTERNATE2 = 0x76;
static const uint8_t I2C_ADDRESS_ALTERNATE3 = 0x77;
static const uint8_t DEFAULT_SDA_PIN = 20;
static const uint8_t DEFAULT_SCL_PIN = 21;
//--------------------------------------------------
// Variables
//--------------------------------------------------
private:
i2c_inst_t *i2c = i2c0;
I2C *i2c;
// interface pins with our standard defaults where appropriate
int8_t address = DEFAULT_I2C_ADDRESS;
int8_t sda = DEFAULT_SDA_PIN;
int8_t scl = DEFAULT_SCL_PIN;
uint8_t buf[145];
@ -39,11 +37,14 @@ namespace pimoroni {
public:
IS31FL3731() {}
IS31FL3731(uint8_t address) :
address(address) {}
IS31FL3731(uint8_t address) : IS31FL3731(new I2C(I2C_DEFAULT_SDA, I2C_DEFAULT_SCL), address) {}
IS31FL3731(I2C *i2c, uint8_t address = DEFAULT_I2C_ADDRESS) : i2c(i2c), address(address) {}
IS31FL3731(i2c_inst_t *i2c, uint8_t address, uint8_t sda, uint8_t scl) :
i2c(i2c), address(address), sda(sda), scl(scl) {}
IS31FL3731(i2c_inst_t *i2c_inst, uint8_t address, uint8_t sda, uint8_t scl) :
address(address) {
i2c = new I2C(sda, scl);
}
//--------------------------------------------------

2
drivers/ltp305/ltp305.cmake
Wyświetl plik

@ -7,4 +7,4 @@ target_sources(${DRIVER_NAME} INTERFACE
target_include_directories(${DRIVER_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c)
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c pimoroni_i2c)

30
drivers/ltp305/ltp305.cpp
Wyświetl plik

@ -5,11 +5,6 @@
namespace pimoroni {
bool LTP305::init() {
i2c_init(i2c, 400000);
gpio_set_function(sda, GPIO_FUNC_I2C); gpio_pull_up(sda);
gpio_set_function(scl, GPIO_FUNC_I2C); gpio_pull_up(scl);
set_brightness(DEFAULT_BRIGHTNESS);
clear();
@ -17,7 +12,7 @@ namespace pimoroni {
}
i2c_inst_t* LTP305::get_i2c() const {
return i2c;
return i2c->get_i2c();
}
int LTP305::get_address() const {
@ -25,17 +20,17 @@ namespace pimoroni {
}
int LTP305::get_sda() const {
return sda;
return i2c->get_sda();
}
int LTP305::get_scl() const {
return scl;
return i2c->get_scl();
}
void LTP305::set_brightness(uint8_t brightness, bool update) {
brightness = std::min((uint8_t)MAX_BRIGHTNESS, brightness);
if(update)
i2c_reg_write_uint8(CMD_BRIGHTNESS, brightness);
i2c->reg_write_uint8(address, CMD_BRIGHTNESS, brightness);
}
void LTP305::set_decimal(bool left, bool right) {
@ -120,17 +115,12 @@ namespace pimoroni {
}
void LTP305::show() {
i2c_write_blocking(i2c, address, buf_matrix_left, BUFFER_CMD + BUFFER_LENGTH, false);
i2c_write_blocking(i2c, address, buf_matrix_right, BUFFER_CMD + BUFFER_LENGTH, false);
i2c->write_blocking(address, buf_matrix_left, BUFFER_CMD + BUFFER_LENGTH, false);
i2c->write_blocking(address, buf_matrix_right, BUFFER_CMD + BUFFER_LENGTH, false);
i2c_reg_write_uint8(CMD_MODE, MODE);
i2c_reg_write_uint8(CMD_OPTIONS, OPTS);
i2c_reg_write_uint8(CMD_BRIGHTNESS, brightness);
i2c_reg_write_uint8(CMD_UPDATE, 0x01);
}
void LTP305::i2c_reg_write_uint8(uint8_t reg, uint8_t value) {
uint8_t buffer[2] = {reg, value};
i2c_write_blocking(i2c, address, buffer, 2, false);
i2c->reg_write_uint8(address, CMD_MODE, MODE);
i2c->reg_write_uint8(address, CMD_OPTIONS, OPTS);
i2c->reg_write_uint8(address, CMD_BRIGHTNESS, brightness);
i2c->reg_write_uint8(address, CMD_UPDATE, 0x01);
}
}

16
drivers/ltp305/ltp305.hpp
Wyświetl plik

@ -2,6 +2,7 @@
#include "hardware/i2c.h"
#include "hardware/gpio.h"
#include "common/pimoroni_i2c.hpp"
namespace pimoroni {
@ -16,8 +17,6 @@ namespace pimoroni {
static const uint8_t DEFAULT_I2C_ADDRESS = 0x61;
static const uint8_t I2C_ADDRESS_ALTERNATE1 = 0x62;
static const uint8_t I2C_ADDRESS_ALTERNATE2 = 0x63;
static const uint8_t DEFAULT_SDA_PIN = 20;
static const uint8_t DEFAULT_SCL_PIN = 21;
static const uint8_t DEFAULT_BRIGHTNESS = 64;
static const uint8_t MAX_BRIGHTNESS = 127;
@ -43,12 +42,10 @@ namespace pimoroni {
// Variables
//--------------------------------------------------
private:
i2c_inst_t *i2c = i2c0;
I2C *i2c;
// interface pins with our standard defaults where appropriate
int8_t address = DEFAULT_I2C_ADDRESS;
int8_t sda = DEFAULT_SDA_PIN;
int8_t scl = DEFAULT_SCL_PIN;
uint8_t brightness = DEFAULT_BRIGHTNESS;
@ -91,8 +88,10 @@ namespace pimoroni {
LTP305(uint8_t address) :
address(address) {}
LTP305(i2c_inst_t *i2c, uint8_t address, uint8_t sda, uint8_t scl) :
i2c(i2c), address(address), sda(sda), scl(scl) {}
LTP305(I2C *i2c, uint8_t address = DEFAULT_I2C_ADDRESS) :
i2c(i2c), address(address) {}
LTP305(i2c_inst_t *i2c, uint8_t address, uint8_t sda, uint8_t scl) : LTP305(new I2C(sda, scl), address) {}
//--------------------------------------------------
@ -114,9 +113,6 @@ namespace pimoroni {
uint16_t offset_x, uint16_t offset_y, bool wrap = false, bool bg = false, uint8_t on_level = DEFAULT_ON_LEVEL, uint8_t padding = 0);
void clear();
void show();
private:
void i2c_reg_write_uint8(uint8_t reg, uint8_t value);
};
}

2
drivers/ltr559/ltr559.cmake
Wyświetl plik

@ -7,4 +7,4 @@ target_sources(${DRIVER_NAME} INTERFACE
target_include_directories(${DRIVER_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c)
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c pimoroni_i2c)

90
drivers/ltr559/ltr559.cpp
Wyświetl plik

@ -27,11 +27,6 @@ namespace pimoroni {
pimoroni::lookup LTR559::lookup_light_gain({1, 2, 4, 8, 0, 0, 48, 96});
bool LTR559::init() {
i2c_init(i2c, 400000);
gpio_set_function(sda, GPIO_FUNC_I2C); gpio_pull_up(sda);
gpio_set_function(scl, GPIO_FUNC_I2C); gpio_pull_up(scl);
if(interrupt != PIN_UNUSED) {
gpio_set_function(interrupt, GPIO_FUNC_SIO);
gpio_set_dir(interrupt, GPIO_IN);
@ -64,15 +59,15 @@ namespace pimoroni {
}
void LTR559::reset() {
set_bits(LTR559_ALS_CONTROL, LTR559_ALS_CONTROL_SW_RESET_BIT);
i2c->set_bits(address, LTR559_ALS_CONTROL, LTR559_ALS_CONTROL_SW_RESET_BIT);
while(get_bits(LTR559_ALS_CONTROL, LTR559_ALS_CONTROL_SW_RESET_BIT)) {
while(i2c->get_bits(address, LTR559_ALS_CONTROL, LTR559_ALS_CONTROL_SW_RESET_BIT)) {
sleep_ms(100);
}
}
i2c_inst_t* LTR559::get_i2c() const {
return i2c;
return i2c->get_i2c();
}
int LTR559::get_address() const {
@ -80,11 +75,11 @@ namespace pimoroni {
}
int LTR559::get_sda() const {
return sda;
return i2c->get_sda();
}
int LTR559::get_scl() const {
return scl;
return i2c->get_sda();
}
int LTR559::get_int() const {
@ -94,26 +89,26 @@ namespace pimoroni {
uint8_t LTR559::part_id() {
uint8_t part_id;
read_bytes(LTR559_PART_ID, &part_id, 1);
i2c->read_bytes(address, LTR559_PART_ID, &part_id, 1);
return (part_id >> LTR559_PART_ID_PART_NUMBER_SHIFT) & LTR559_PART_ID_PART_NUMBER_MASK;
}
uint8_t LTR559::revision_id() {
uint8_t revision_id;
read_bytes(LTR559_PART_ID, &revision_id, 1);
i2c->read_bytes(address, LTR559_PART_ID, &revision_id, 1);
return revision_id & LTR559_PART_ID_REVISION_MASK;
}
uint8_t LTR559::manufacturer_id() {
uint8_t manufacturer;
read_bytes(LTR559_MANUFACTURER_ID, &manufacturer, 1);
i2c->read_bytes(address, LTR559_MANUFACTURER_ID, &manufacturer, 1);
return manufacturer;
}
bool LTR559::get_reading() {
bool has_updated = false;
uint8_t status;
this->read_bytes(LTR559_ALS_PS_STATUS, &status, 1);
i2c->read_bytes(address, LTR559_ALS_PS_STATUS, &status, 1);
bool als_int = (status >> LTR559_ALS_PS_STATUS_ALS_INTERRUPT_BIT) & 0b1;
bool ps_int = (status >> LTR559_ALS_PS_STATUS_PS_INTERRUPT_BIT) & 0b1;
bool als_data = (status >> LTR559_ALS_PS_STATUS_ALS_DATA_BIT) & 0b1;
@ -122,7 +117,7 @@ namespace pimoroni {
if(ps_int || ps_data) {
has_updated = true;
uint16_t ps0;
read_bytes(LTR559_PS_DATA, (uint8_t *)&ps0, 2);
i2c->read_bytes(address, LTR559_PS_DATA, (uint8_t *)&ps0, 2);
ps0 &= LTR559_PS_DATA_MASK;
data.proximity = ps0;
@ -131,7 +126,7 @@ namespace pimoroni {
if(als_int || als_data) {
has_updated = true;
uint16_t als[2];
read_bytes(LTR559_ALS_DATA_CH1, (uint8_t *)&als, 4);
i2c->read_bytes(address, LTR559_ALS_DATA_CH1, (uint8_t *)&als, 4);
data.als0 = als[1];
data.als1 = als[0];
data.gain = this->lookup_light_gain.value((status >> LTR559_ALS_PS_STATUS_ALS_GAIN_SHIFT) & LTR559_ALS_PS_STATUS_ALS_GAIN_MASK);
@ -164,7 +159,7 @@ namespace pimoroni {
buf |= 0b1 << LTR559_INTERRUPT_POLARITY_BIT;
buf |= (uint8_t)light << LTR559_INTERRUPT_ALS_BIT;
buf |= (uint8_t)proximity << LTR559_INTERRUPT_PS_BIT;
write_bytes(LTR559_INTERRUPT, &buf, 1);
i2c->write_bytes(address, LTR559_INTERRUPT, &buf, 1);
}
void LTR559::proximity_led(uint8_t current, uint8_t duty_cycle, uint8_t pulse_freq, uint8_t num_pulses) {
@ -177,10 +172,10 @@ namespace pimoroni {
pulse_freq <<= LTR559_PS_LED_PULSE_FREQ_SHIFT;
uint8_t buf = current | duty_cycle | pulse_freq;
write_bytes(LTR559_PS_LED, &buf, 1);
i2c->write_bytes(address, LTR559_PS_LED, &buf, 1);
buf = num_pulses & LTR559_PS_N_PULSES_MASK;
write_bytes(LTR559_PS_N_PULSES, &buf, 1);
i2c->write_bytes(address, LTR559_PS_N_PULSES, &buf, 1);
}
void LTR559::light_control(bool active, uint8_t gain) {
@ -193,12 +188,12 @@ namespace pimoroni {
else
buf &= ~(0b1 << LTR559_ALS_CONTROL_MODE_BIT);
write_bytes(LTR559_ALS_CONTROL, &buf, 1);
i2c->write_bytes(address, LTR559_ALS_CONTROL, &buf, 1);
}
void LTR559::proximity_control(bool active, bool saturation_indicator) {
uint8_t buf = 0;
read_bytes(LTR559_PS_CONTROL, &buf, 1);
i2c->read_bytes(address, LTR559_PS_CONTROL, &buf, 1);
if(active)
buf |= LTR559_PS_CONTROL_ACTIVE_MASK;
else
@ -209,21 +204,21 @@ namespace pimoroni {
else
buf &= ~(0b1 << LTR559_PS_CONTROL_SATURATION_INDICATOR_ENABLE_BIT);
write_bytes(LTR559_PS_CONTROL, &buf, 1);
i2c->write_bytes(address, LTR559_PS_CONTROL, &buf, 1);
}
void LTR559::light_threshold(uint16_t lower, uint16_t upper) {
lower = __builtin_bswap16(lower);
upper = __builtin_bswap16(upper);
write_bytes(LTR559_ALS_THRESHOLD_LOWER, (uint8_t *)&lower, 2);
write_bytes(LTR559_ALS_THRESHOLD_UPPER, (uint8_t *)&upper, 2);
i2c->write_bytes(address, LTR559_ALS_THRESHOLD_LOWER, (uint8_t *)&lower, 2);
i2c->write_bytes(address, LTR559_ALS_THRESHOLD_UPPER, (uint8_t *)&upper, 2);
}
void LTR559::proximity_threshold(uint16_t lower, uint16_t upper) {
lower = uint16_to_bit12(lower);
upper = uint16_to_bit12(upper);
write_bytes(LTR559_PS_THRESHOLD_LOWER, (uint8_t *)&lower, 2);
write_bytes(LTR559_PS_THRESHOLD_UPPER, (uint8_t *)&upper, 2);
i2c->write_bytes(address, LTR559_PS_THRESHOLD_LOWER, (uint8_t *)&lower, 2);
i2c->write_bytes(address, LTR559_PS_THRESHOLD_UPPER, (uint8_t *)&upper, 2);
}
void LTR559::light_measurement_rate(uint16_t integration_time, uint16_t rate) {
@ -233,17 +228,17 @@ namespace pimoroni {
uint8_t buf = 0;
buf |= rate;
buf |= integration_time << LTR559_ALS_MEAS_RATE_INTEGRATION_TIME_SHIFT;
write_bytes(LTR559_ALS_MEAS_RATE, &buf, 1);
i2c->write_bytes(address, LTR559_ALS_MEAS_RATE, &buf, 1);
}
void LTR559::proximity_measurement_rate(uint16_t rate) {
uint8_t buf = lookup_proximity_meas_rate.index(rate);
write_bytes(LTR559_PS_MEAS_RATE, &buf, 1);
i2c->write_bytes(address, LTR559_PS_MEAS_RATE, &buf, 1);
}
void LTR559::proximity_offset(uint16_t offset) {
offset &= LTR559_PS_OFFSET_MASK;
write_bytes(LTR559_PS_OFFSET, (uint8_t *)&offset, 1);
i2c->write_bytes(address, LTR559_PS_OFFSET, (uint8_t *)&offset, 1);
}
uint16_t LTR559::bit12_to_uint16(uint16_t value) {
@ -253,41 +248,4 @@ namespace pimoroni {
uint16_t LTR559::uint16_to_bit12(uint16_t value) {
return ((value & 0xFF) << 8) | ((value & 0xF00) >> 8);
}
// i2c functions
int LTR559::write_bytes(uint8_t reg, uint8_t *buf, int len) {
uint8_t buffer[len + 1];
buffer[0] = reg;
for(int x = 0; x < len; x++) {
buffer[x + 1] = buf[x];
}
return i2c_write_blocking(i2c, address, buffer, len + 1, false);
};
int LTR559::read_bytes(uint8_t reg, uint8_t *buf, int len) {
i2c_write_blocking(i2c, address, &reg, 1, true);
i2c_read_blocking(i2c, address, buf, len, false);
return len;
};
uint8_t LTR559::get_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
uint8_t value;
read_bytes(reg, &value, 1);
return value & (mask << shift);
}
void LTR559::set_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
uint8_t value;
read_bytes(reg, &value, 1);
value |= mask << shift;
write_bytes(reg, &value, 1);
}
void LTR559::clear_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
uint8_t value;
read_bytes(reg, &value, 1);
value &= ~(mask << shift);
write_bytes(reg, &value, 1);
}
}

38
drivers/ltr559/ltr559.hpp
Wyświetl plik

@ -1,7 +1,8 @@
#pragma once
#include "hardware/i2c.h"
#include "hardware/gpio.h"
#include "common/pimoroni_common.hpp"
#include "common/pimoroni_i2c.hpp"
#include <vector>
#include <initializer_list>
@ -85,6 +86,7 @@
namespace pimoroni {
typedef struct {
uint16_t proximity;
uint16_t als0;
@ -127,13 +129,11 @@ namespace pimoroni {
ltr559_reading data;
private:
i2c_inst_t *i2c = i2c0;
I2C *i2c;
// interface pins with our standard defaults where appropriate
int8_t address = DEFAULT_I2C_ADDRESS;
int8_t sda = DEFAULT_SDA_PIN;
int8_t scl = DEFAULT_SCL_PIN;
int8_t interrupt = DEFAULT_INT_PIN;
uint8_t address = DEFAULT_I2C_ADDRESS;
uint8_t interrupt = DEFAULT_INT_PIN;
static pimoroni::lookup lookup_led_current;
static pimoroni::lookup lookup_led_duty_cycle;
@ -148,14 +148,17 @@ namespace pimoroni {
// Constructors/Destructor
//--------------------------------------------------
public:
LTR559() {}
LTR559(uint8_t address) :
address(address) {}
LTR559(i2c_inst_t *i2c, uint8_t address, uint8_t sda, uint8_t scl, uint8_t interrupt = PIN_UNUSED) :
i2c(i2c), address(address), sda(sda), scl(scl), interrupt(interrupt) {}
LTR559() {
i2c = new I2C(DEFAULT_SDA_PIN, DEFAULT_SCL_PIN);
};
LTR559(uint8_t address) : address(address) {
i2c = new I2C(DEFAULT_SDA_PIN, DEFAULT_SCL_PIN);
};
LTR559(i2c_inst_t *i2c_inst, uint8_t address, uint sda, uint scl, uint8_t interrupt = PIN_UNUSED) : address(address), interrupt(interrupt) {
i2c = new I2C(sda, scl);
}
LTR559(I2C *i2c, uint8_t address = DEFAULT_I2C_ADDRESS, uint8_t interrupt = PIN_UNUSED) :
i2c(i2c), address(address), interrupt(interrupt) {}
//--------------------------------------------------
// Methods
@ -188,13 +191,6 @@ namespace pimoroni {
private:
uint16_t bit12_to_uint16(uint16_t value);
uint16_t uint16_to_bit12(uint16_t value);
// From i2cdevice
int write_bytes(uint8_t reg, uint8_t *buf, int len);
int read_bytes(uint8_t reg, uint8_t *buf, int len);
uint8_t get_bits(uint8_t reg, uint8_t shift, uint8_t mask=0b1);
void set_bits(uint8_t reg, uint8_t shift, uint8_t mask=0b1);
void clear_bits(uint8_t reg, uint8_t shift, uint8_t mask=0b1);
};
}

11
drivers/msa301/CMakeLists.txt
Wyświetl plik

@ -1,10 +1 @@
add_library(msa301 INTERFACE)
target_sources(msa301 INTERFACE
${CMAKE_CURRENT_LIST_DIR}/msa301.cpp
)
target_include_directories(msa301 INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(msa301 INTERFACE pico_stdlib hardware_i2c)
include(msa301.cmake)

2
drivers/msa301/msa301.cmake
Wyświetl plik

@ -7,4 +7,4 @@ target_sources(msa301 INTERFACE
target_include_directories(msa301 INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(msa301 INTERFACE pico_stdlib hardware_i2c)
target_link_libraries(msa301 INTERFACE pico_stdlib hardware_i2c pimoroni_i2c)

56
drivers/msa301/msa301.cpp
Wyświetl plik

@ -8,11 +8,6 @@
namespace pimoroni {
bool MSA301::init() {
i2c_init(i2c, 400000);
gpio_set_function(sda, GPIO_FUNC_I2C); gpio_pull_up(sda);
gpio_set_function(scl, GPIO_FUNC_I2C); gpio_pull_up(scl);
if(interrupt != PIN_UNUSED) {
gpio_set_function(interrupt, GPIO_FUNC_SIO);
gpio_set_dir(interrupt, GPIO_IN);
@ -28,20 +23,20 @@ namespace pimoroni {
}
void MSA301::reset() {
i2c_reg_write_uint8(SOFT_RESET, 0b00100100);
i2c->reg_write_uint8(address, SOFT_RESET, 0b00100100);
sleep_ms(1);
}
i2c_inst_t* MSA301::get_i2c() const {
return i2c;
return i2c->get_i2c();
}
int MSA301::get_sda() const {
return sda;
return i2c->get_sda();
}
int MSA301::get_scl() const {
return scl;
return i2c->get_scl();
}
int MSA301::get_int() const {
@ -49,20 +44,20 @@ namespace pimoroni {
}
uint8_t MSA301::part_id() {
return i2c_reg_read_uint8(PART_ID);
return i2c->reg_read_uint8(address, PART_ID);
}
float MSA301::get_axis(Axis axis, uint8_t sample_count) {
if(sample_count > 1) {
int32_t total = 0;
for(uint8_t i = 0; i < sample_count; i++) {
total += i2c_reg_read_int16((int)axis);
total += i2c->reg_read_int16(address, (int)axis);
}
total /= sample_count;
return total / 16384.0f;
}
return i2c_reg_read_int16(axis) / 16384.0f;
return i2c->reg_read_int16(address, axis) / 16384.0f;
}
float MSA301::get_x_axis(uint8_t sample_count) {
@ -78,19 +73,19 @@ namespace pimoroni {
}
MSA301::Orientation MSA301::get_orientation() {
return (Orientation)((i2c_reg_read_uint8(ORIENTATION_STATUS) >> 4) & 0b11);
return (Orientation)((i2c->reg_read_uint8(address, ORIENTATION_STATUS) >> 4) & 0b11);
}
void MSA301::set_power_mode(MSA301::PowerMode power_mode) {
i2c_reg_write_uint8(POWER_MODE_BANDWIDTH, power_mode);
i2c->reg_write_uint8(address, POWER_MODE_BANDWIDTH, power_mode);
}
void MSA301::set_range_and_resolution(Range range, MSA301::Resolution resolution) {
i2c_reg_write_uint8(RESOLUTION_RANGE, range | resolution);
i2c->reg_write_uint8(address, RESOLUTION_RANGE, range | resolution);
}
void MSA301::set_axis_polarity(uint8_t polarity) {
i2c_reg_write_uint8(SET_AXIS_POLARITY, polarity);
i2c->reg_write_uint8(address, SET_AXIS_POLARITY, polarity);
}
void MSA301::disable_all_interrupts() {
@ -98,17 +93,17 @@ namespace pimoroni {
}
void MSA301::enable_interrupts(uint16_t interrupts) {
i2c_reg_write_uint8(INTERRUPT_ENABLE_0, interrupts & 0xff);
i2c_reg_write_uint8(INTERRUPT_ENABLE_1, (interrupts & 0xff00) >> 8);
i2c->reg_write_uint8(address, INTERRUPT_ENABLE_0, interrupts & 0xff);
i2c->reg_write_uint8(address, INTERRUPT_ENABLE_1, (interrupts & 0xff00) >> 8);
}
void MSA301::set_interrupt_latch(MSA301::InterruptLatchPeriod latch_period, bool reset_latched = false) {
i2c_reg_write_uint8(INTERRUPT_LATCH_PERIOD, latch_period | (reset_latched ? 0b10000000: 0b0));
i2c->reg_write_uint8(address, INTERRUPT_LATCH_PERIOD, latch_period | (reset_latched ? 0b10000000: 0b0));
}
bool MSA301::read_interrupt(Interrupt interrupt) {
if(interrupt == NEW_DATA) {
return i2c_reg_read_uint8(DATA_INTERRUPT) & 0b1;
return i2c->reg_read_uint8(address, DATA_INTERRUPT) & 0b1;
}
// determine which bit indicates the status of this interrupt
@ -119,26 +114,7 @@ namespace pimoroni {
if(interrupt == SINGLE_TAP) bit = 5;
if(interrupt == ORIENTATION) bit = 6;
return i2c_reg_read_uint8(MOTION_INTERRUPT) & (1U << bit);
}
void MSA301::i2c_reg_write_uint8(uint8_t reg, uint8_t value) {
uint8_t buffer[2] = {reg, value};
i2c_write_blocking(i2c, address, buffer, 2, false);
}
uint8_t MSA301::i2c_reg_read_uint8(uint8_t reg) {
uint8_t value;
i2c_write_blocking(i2c, address, &reg, 1, true);
i2c_read_blocking(i2c, address, (uint8_t *)&value, 1, false);
return value;
}
int16_t MSA301::i2c_reg_read_int16(uint8_t reg) {
int16_t value;
i2c_write_blocking(i2c, address, &reg, 1, true);
i2c_read_blocking(i2c, address, (uint8_t *)&value, 2, false);
return value;
return i2c->reg_read_uint8(address, MOTION_INTERRUPT) & (1U << bit);
}
}

33
drivers/msa301/msa301.hpp
Wyświetl plik

@ -2,7 +2,8 @@
#include "hardware/i2c.h"
#include "hardware/gpio.h"
#include "common/pimoroni.hpp"
#include "common/pimoroni_common.hpp"
#include "common/pimoroni_i2c.hpp"
namespace pimoroni {
@ -107,24 +108,27 @@ namespace pimoroni {
// Variables
//--------------------------------------------------
private:
i2c_inst_t *i2c = i2c0;
I2C *i2c;
// interface pins with our standard defaults where appropriate
int8_t address = DEFAULT_I2C_ADDRESS;
uint sda = I2C_DEFAULT_SDA;
uint scl = I2C_DEFAULT_SCL;
uint interrupt = I2C_DEFAULT_INT;
i2c_inst_t *i2c = PIMORONI_I2C_DEFAULT_INSTANCE;
uint8_t address = DEFAULT_I2C_ADDRESS;
uint interrupt = I2C_DEFAULT_INT;
//--------------------------------------------------
// Constructors/Destructor
//--------------------------------------------------
public:
MSA301() {}
MSA301(i2c_inst_t *i2c, uint sda, uint scl, uint interrupt) :
i2c(i2c), sda(sda), scl(scl), interrupt(interrupt) {}
MSA301() {
i2c = new I2C(DEFAULT_SDA_PIN, DEFAULT_SCL_PIN);
};
MSA301(uint8_t address) : address(address) {
i2c = new I2C(DEFAULT_SDA_PIN, DEFAULT_SCL_PIN);
};
MSA301(i2c_inst_t *i2c_inst, uint8_t address, uint sda, uint scl, uint8_t interrupt = PIN_UNUSED) : address(address), interrupt(interrupt) {
i2c = new I2C(sda, scl);
}
MSA301(I2C *i2c, uint8_t address = DEFAULT_I2C_ADDRESS, uint interrupt = PIN_UNUSED) :
i2c(i2c), address(address), interrupt(interrupt) {}
//--------------------------------------------------
@ -154,11 +158,6 @@ namespace pimoroni {
void enable_interrupts(uint16_t interrupts);
void set_interrupt_latch(InterruptLatchPeriod latch_period, bool reset_latched);
bool read_interrupt(Interrupt interrupt);
private:
void i2c_reg_write_uint8(uint8_t reg, uint8_t value);
uint8_t i2c_reg_read_uint8(uint8_t reg);
int16_t i2c_reg_read_int16(uint8_t reg);
};
}

2
drivers/rv3028/rv3028.cmake
Wyświetl plik

@ -7,4 +7,4 @@ target_sources(${DRIVER_NAME} INTERFACE
target_include_directories(${DRIVER_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c)
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c pimoroni_i2c)

68
drivers/rv3028/rv3028.cpp
Wyświetl plik

@ -61,13 +61,6 @@ BUILD_MONTH_OCT | BUILD_MONTH_NOV | BUILD_MONTH_DEC
namespace pimoroni {
bool RV3028::init() {
i2c_init(i2c, 400000);
gpio_set_function(sda, GPIO_FUNC_I2C);
gpio_pull_up(sda);
gpio_set_function(scl, GPIO_FUNC_I2C);
gpio_pull_up(scl);
if(interrupt != PIN_UNUSED) {
gpio_set_function(interrupt, GPIO_FUNC_SIO);
gpio_set_dir(interrupt, GPIO_IN);
@ -75,7 +68,7 @@ namespace pimoroni {
}
uint8_t chip_id = 0;
read_bytes(RV3028_ID, &chip_id, 1);
i2c->read_bytes(address, RV3028_ID, &chip_id, 1);
if(chip_id != (RV3028_CHIP_ID | RV3028_VERSION)) {
return false;
}
@ -88,15 +81,15 @@ namespace pimoroni {
}
i2c_inst_t* RV3028::get_i2c() const {
return i2c;
return i2c->get_i2c();
}
int RV3028::get_sda() const {
return sda;
return i2c->get_sda();
}
int RV3028::get_scl() const {
return scl;
return i2c->get_scl();
}
int RV3028::get_int() const {
@ -712,7 +705,7 @@ namespace pimoroni {
// Returns the status byte
uint8_t RV3028::status(void) {
return(read_register(RV3028_STATUS));
return read_register(RV3028_STATUS);
}
void RV3028::clear_interrupts() { // Read the status register to clear the current interrupt flags
@ -733,7 +726,7 @@ namespace pimoroni {
uint8_t RV3028::read_register(uint8_t addr) {
uint8_t b1[2];
if(1 == RV3028::read_bytes(addr, b1, 1))
if(1 == i2c->read_bytes(address, addr, b1, 1))
return b1[0];
else
return 0xFF; //Error
@ -743,15 +736,15 @@ namespace pimoroni {
uint8_t b1[2];
b1[0] = val;
b1[1] = 0;
return(RV3028::write_bytes(addr, b1, 1));
return i2c->write_bytes(address, addr, b1, 1);
}
bool RV3028::read_multiple_registers(uint8_t addr, uint8_t *dest, uint8_t len) {
return(RV3028::read_bytes(addr, dest, len));
return i2c->read_bytes(address, addr, dest, len);
}
bool RV3028::write_multiple_registers(uint8_t addr, uint8_t *values, uint8_t len) {
return(RV3028::write_bytes(addr, values, len));
return i2c->write_bytes(address, addr, values, len);
}
bool RV3028::write_config_eeprom_ram_mirror(uint8_t eeprom_addr, uint8_t val) {
@ -833,52 +826,15 @@ namespace pimoroni {
}
void RV3028::set_bit(uint8_t reg_addr, uint8_t bit_num) {
RV3028::set_bits(reg_addr, bit_num, 0x01);
i2c->set_bits(address, reg_addr, bit_num, 0x01);
}
void RV3028::clear_bit(uint8_t reg_addr, uint8_t bit_num) {
RV3028::clear_bits(reg_addr, bit_num, 0x01);
i2c->clear_bits(address, reg_addr, bit_num, 0x01);
}
bool RV3028::read_bit(uint8_t reg_addr, uint8_t bit_num) {
uint8_t value = RV3028::get_bits(reg_addr, bit_num, 0x01);
uint8_t value = i2c->get_bits(address, reg_addr, bit_num, 0x01);
return value;
}
// i2c functions
int RV3028::write_bytes(uint8_t reg, uint8_t *buf, int len) {
uint8_t buffer[len + 1];
buffer[0] = reg;
for(int x = 0; x < len; x++) {
buffer[x + 1] = buf[x];
}
return i2c_write_blocking(i2c, address, buffer, len + 1, false);
};
int RV3028::read_bytes(uint8_t reg, uint8_t *buf, int len) {
i2c_write_blocking(i2c, address, &reg, 1, true);
i2c_read_blocking(i2c, address, buf, len, false);
return len;
};
uint8_t RV3028::get_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
uint8_t value;
read_bytes(reg, &value, 1);
return value & (mask << shift);
}
void RV3028::set_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
uint8_t value;
read_bytes(reg, &value, 1);
value |= mask << shift;
write_bytes(reg, &value, 1);
}
void RV3028::clear_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
uint8_t value;
read_bytes(reg, &value, 1);
value &= ~(mask << shift);
write_bytes(reg, &value, 1);
}
}

25
drivers/rv3028/rv3028.hpp
Wyświetl plik

@ -12,7 +12,8 @@ Distributed as-is; no warranty is given.
#include "hardware/i2c.h"
#include "hardware/gpio.h"
#include "common/pimoroni.hpp"
#include "common/pimoroni_common.hpp"
#include "common/pimoroni_i2c.hpp"
#include <stdio.h>
#include <stdlib.h>
@ -197,8 +198,6 @@ namespace pimoroni {
//--------------------------------------------------
public:
static const uint8_t DEFAULT_I2C_ADDRESS = RV3028_ADDR;
static const uint8_t DEFAULT_SDA_PIN = 20;
static const uint8_t DEFAULT_SCL_PIN = 21;
static const uint8_t DEFAULT_INT_PIN = 22;
static const uint8_t PIN_UNUSED = UINT8_MAX;
@ -207,12 +206,10 @@ namespace pimoroni {
// Variables
//--------------------------------------------------
private:
i2c_inst_t *i2c = PIMORONI_I2C_DEFAULT_INSTANCE;
I2C *i2c;
// interface pins with our standard defaults where appropriate
int8_t address = DEFAULT_I2C_ADDRESS;
uint sda = DEFAULT_SDA_PIN;
uint scl = DEFAULT_SCL_PIN;
uint interrupt = DEFAULT_INT_PIN;
uint8_t times[TIME_ARRAY_LENGTH];
@ -224,8 +221,13 @@ namespace pimoroni {
public:
RV3028() {}
RV3028(i2c_inst_t *i2c, uint8_t sda, uint8_t scl, uint8_t interrupt = PIN_UNUSED) :
i2c(i2c), sda(sda), scl(scl), interrupt(interrupt) {}
RV3028(uint8_t address) :
address(address) {}
RV3028(I2C *i2c, uint8_t address = DEFAULT_I2C_ADDRESS, uint interrupt = DEFAULT_INT_PIN) :
i2c(i2c), address(address), interrupt(interrupt) {}
RV3028(i2c_inst_t *i2c, uint8_t address, uint8_t sda, uint8_t scl) : RV3028(new I2C(sda, scl), address) {}
//--------------------------------------------------
@ -325,13 +327,6 @@ private:
void set_bit(uint8_t reg_addr, uint8_t bit_num);
void clear_bit(uint8_t reg_addr, uint8_t bit_num);
bool read_bit(uint8_t reg_addr, uint8_t bit_num);
// From i2cdevice
int write_bytes(uint8_t reg, uint8_t *buf, int len);
int read_bytes(uint8_t reg, uint8_t *buf, int len);
uint8_t get_bits(uint8_t reg, uint8_t shift, uint8_t mask = 0b1);
void set_bits(uint8_t reg, uint8_t shift, uint8_t mask = 0b1);
void clear_bits(uint8_t reg, uint8_t shift, uint8_t mask = 0b1);
};
// POSSIBLE ENHANCEMENTS :

2
drivers/sgp30/sgp30.cmake
Wyświetl plik

@ -7,4 +7,4 @@ target_sources(${DRIVER_NAME} INTERFACE
target_include_directories(${DRIVER_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c)
target_link_libraries(${DRIVER_NAME} INTERFACE pico_stdlib hardware_i2c pimoroni_i2c)

34
drivers/sgp30/sgp30.cpp
Wyświetl plik

@ -14,14 +14,6 @@ Distributed as-is; no warranty is given.
namespace pimoroni {
bool SGP30::init() {
i2c_init(i2c, 400000);
gpio_set_function(sda, GPIO_FUNC_I2C);
gpio_pull_up(sda);
gpio_set_function(scl, GPIO_FUNC_I2C);
gpio_pull_up(scl);
soft_reset();
if(!retrieve_unique_id()) {
@ -46,15 +38,15 @@ namespace pimoroni {
}
i2c_inst_t* SGP30::get_i2c() const {
return i2c;
return i2c->get_i2c();
}
int SGP30::get_sda() const {
return sda;
return i2c->get_sda();
}
int SGP30::get_scl() const {
return scl;
return i2c->get_scl();
}
// Get the unique ID from the Chip. Will fail if no chip attached
@ -137,7 +129,7 @@ namespace pimoroni {
// Write a single byte globally (not to a specifc I2c address)
bool SGP30::write_global(uint16_t reg, uint16_t delay_ms) {
uint8_t buffer[1] = { (uint8_t)(reg & 0xFF)};
i2c_write_blocking(i2c, 0, buffer, 1, false);
i2c->write_blocking(0, buffer, 1, false);
sleep_ms(delay_ms);
return true;
}
@ -145,7 +137,7 @@ namespace pimoroni {
// Write just the register to the i2c address, no parameter
bool SGP30::write_reg(uint16_t reg, uint16_t delay_ms) {
uint8_t buffer[2] = { (uint8_t)((reg >> 8) & 0xFF), (uint8_t)(reg & 0xFF)};
i2c_write_blocking(i2c, address, buffer, 2, false);
i2c->write_blocking(address, buffer, 2, false);
sleep_ms(delay_ms);
return true;
}
@ -154,7 +146,7 @@ namespace pimoroni {
bool SGP30::write_reg_1_word(uint16_t reg, uint16_t delay_ms, uint16_t value) {
uint8_t buffer[5] = { (uint8_t)((reg >> 8) & 0xFF), (uint8_t)(reg & 0xFF),
(uint8_t)((value >> 8) & 0xFF), (uint8_t)(value & 0xFF), calculate_crc(value)};
i2c_write_blocking(i2c, address, buffer, 5, false);
i2c->write_blocking(address, buffer, 5, false);
sleep_ms(delay_ms);
return true;
}
@ -164,7 +156,7 @@ namespace pimoroni {
uint8_t buffer[8] = { (uint8_t)((reg >> 8) & 0xFF), (uint8_t)(reg & 0xFF),
(uint8_t)((value1 >> 8) & 0xFF), (uint8_t)(value1 & 0xFF), calculate_crc(value1),
(uint8_t)((value2 >> 8) & 0xFF), (uint8_t)(value2 & 0xFF), calculate_crc(value2)};
i2c_write_blocking(i2c, address, buffer, 8, false);
i2c->write_blocking(address, buffer, 8, false);
sleep_ms(delay_ms);
return true;
}
@ -173,9 +165,9 @@ namespace pimoroni {
bool SGP30::read_reg_1_word(uint16_t reg, uint16_t delay_ms, uint16_t *value) {
uint8_t regbuf[2] = { (uint8_t)((reg >> 8) & 0xFF), (uint8_t)(reg & 0xFF) };
uint8_t buffer[3];
i2c_write_blocking(i2c, address, regbuf, 2, true);
i2c->write_blocking(address, regbuf, 2, true);
sleep_ms(delay_ms);
i2c_read_blocking(i2c, address, buffer, 3, false);
i2c->read_blocking(address, buffer, 3, false);
if(buffer[2] != calculate_crc(buffer[0], buffer[1]))
return false;
*value = (buffer[0] << 8) + buffer[1];
@ -186,9 +178,9 @@ namespace pimoroni {
bool SGP30::read_reg_2_words(uint16_t reg, uint16_t delay_ms, uint16_t *value1, uint16_t *value2) {
uint8_t regbuf[2] = { (uint8_t)((reg >> 8) & 0xFF), (uint8_t)(reg & 0xFF) };
uint8_t buffer[6];
i2c_write_blocking(i2c, address, regbuf, 2, true);
i2c->write_blocking(address, regbuf, 2, true);
sleep_ms(delay_ms);
i2c_read_blocking(i2c, address, buffer, 6, false);
i2c->read_blocking(address, buffer, 6, false);
if((buffer[2] != calculate_crc(buffer[0], buffer[1])) || (buffer[5] != calculate_crc(buffer[3], buffer[4]))) {
return false;
}
@ -201,9 +193,9 @@ namespace pimoroni {
bool SGP30::read_reg_3_words(uint16_t reg, uint16_t delay_ms, uint16_t *value1, uint16_t *value2, uint16_t *value3) {
uint8_t regbuf[2] = { (uint8_t)((reg >> 8) & 0xFF), (uint8_t)(reg & 0xFF) };
uint8_t buffer[9];
i2c_write_blocking(i2c, address, regbuf, 2, true);
i2c->write_blocking(address, regbuf, 2, true);
sleep_ms(delay_ms);
i2c_read_blocking(i2c, address, buffer, 9, false);
i2c->read_blocking(address, buffer, 9, false);
if(buffer[2] != calculate_crc(buffer[0], buffer[1])) {
return false;
}

25
drivers/sgp30/sgp30.hpp
Wyświetl plik

@ -2,6 +2,8 @@
#include "hardware/i2c.h"
#include "hardware/gpio.h"
#include "common/pimoroni_common.hpp"
#include "common/pimoroni_i2c.hpp"
// commands and constants
#define SGP30_REQ_FEATURES 0x0020 // The required feature set
@ -37,22 +39,29 @@ namespace pimoroni {
// Variables
//--------------------------------------------------
private:
i2c_inst_t *i2c = i2c0;
I2C *i2c;
int8_t address = DEFAULT_I2C_ADDRESS;
int8_t sda = DEFAULT_SDA_PIN;
int8_t scl = DEFAULT_SCL_PIN;
//--------------------------------------------------
// Constructors/Destructor
//--------------------------------------------------
public:
SGP30() {}
SGP30(i2c_inst_t *i2c, uint8_t sda, uint8_t scl) :
i2c(i2c), sda(sda), scl(scl) {}
SGP30() {
i2c = new I2C(DEFAULT_SDA_PIN, DEFAULT_SCL_PIN);
};
SGP30(uint8_t address) : address(address) {
i2c = new I2C(DEFAULT_SDA_PIN, DEFAULT_SCL_PIN);
};
SGP30(i2c_inst_t *i2c_inst, uint sda, uint scl) {
i2c = new I2C(sda, scl);
}
SGP30(i2c_inst_t *i2c_inst, uint8_t address, uint sda, uint scl) : address(address) {
i2c = new I2C(sda, scl);
}
SGP30(I2C *i2c, uint8_t address = DEFAULT_I2C_ADDRESS, uint interrupt = PIN_UNUSED) :
i2c(i2c), address(address) {}
//--------------------------------------------------
// Methods

2
drivers/st7735/st7735.hpp
Wyświetl plik

@ -2,7 +2,7 @@
#include "hardware/spi.h"
#include "hardware/gpio.h"
#include "../../common/pimoroni.hpp"
#include "../../common/pimoroni_common.hpp"
namespace pimoroni {

2
drivers/st7789/st7789.hpp
Wyświetl plik

@ -2,7 +2,7 @@
#include "hardware/spi.h"
#include "hardware/gpio.h"
#include "../../common/pimoroni.hpp"
#include "../../common/pimoroni_common.hpp"
namespace pimoroni {

4
examples/breakout_as7262/basic_demo.cpp
Wyświetl plik

@ -1,10 +1,12 @@
#include "pico/stdlib.h"
#include "common/pimoroni_common.hpp"
#include "breakout_as7262.hpp"
using namespace pimoroni;
BreakoutAS7262 as7262;
I2C i2c(BOARD::BREAKOUT_GARDEN);
BreakoutAS7262 as7262(&i2c);
int main() {
stdio_init_all();

4
examples/breakout_as7262/explorer_bargraph.cpp
Wyświetl plik

@ -1,4 +1,5 @@
#include "pico/stdlib.h"
#include "common/pimoroni_common.hpp"
#include "breakout_as7262.hpp"
#include "pico_explorer.hpp"
@ -7,7 +8,8 @@ using namespace pimoroni;
constexpr float INTEGRATION_TIME = 10.0f;
BreakoutAS7262 as7262;
I2C i2c(BOARD::PICO_EXPLORER);
BreakoutAS7262 as7262(&i2c);
uint16_t buffer[PicoExplorer::WIDTH * PicoExplorer::HEIGHT];
PicoExplorer pico_explorer(buffer);

3
examples/breakout_dotmatrix/bargraph/bargraph.cpp
Wyświetl plik

@ -5,7 +5,8 @@
using namespace pimoroni;
BreakoutDotMatrix display;
I2C i2c(BOARD::BREAKOUT_GARDEN);
BreakoutDotMatrix display(&i2c);
static const uint8_t WIDTH = display.WIDTH;
static const uint8_t HEIGHT = display.HEIGHT;
static const uint8_t HALF_WIDTH = (WIDTH / 2);

3
examples/breakout_dotmatrix/eyes/eyes.cpp
Wyświetl plik

@ -5,7 +5,8 @@
using namespace pimoroni;
BreakoutDotMatrix display;
I2C i2c(BOARD::BREAKOUT_GARDEN);
BreakoutDotMatrix display(&i2c);
bool led_toggle = false;
void eye(uint8_t x, uint8_t y) {

3
examples/breakout_dotmatrix/image/image.cpp
Wyświetl plik

@ -4,7 +4,8 @@
using namespace pimoroni;
BreakoutDotMatrix display;
I2C i2c(BOARD::BREAKOUT_GARDEN);
BreakoutDotMatrix display(&i2c);
bool led_toggle = false;
// Left Image Padding Right Image Padding

3
examples/breakout_dotmatrix/timer/timer.cpp
Wyświetl plik

@ -6,7 +6,8 @@
using namespace pimoroni;
BreakoutDotMatrix display(BreakoutDotMatrix::DEFAULT_I2C_ADDRESS);
I2C i2c(BOARD::BREAKOUT_GARDEN);
BreakoutDotMatrix display(&i2c);
bool led_toggle = false;
int main() {

4
examples/breakout_encoder/demo.cpp
Wyświetl plik

@ -1,6 +1,7 @@
#include "pico/stdlib.h"
#include <stdio.h>
#include <math.h>
#include "common/pimoroni_common.hpp"
#include "breakout_encoder.hpp"
@ -8,7 +9,8 @@ using namespace pimoroni;
static const uint8_t STEPS_PER_REV = 24;
BreakoutEncoder enc;
I2C i2c(BOARD::BREAKOUT_GARDEN);
BreakoutEncoder enc(&i2c);
bool toggle = false;
// HSV Conversion expects float inputs in the range of 0.00-1.00 for each channel

3
examples/breakout_ltr559/demo.cpp
Wyświetl plik

@ -5,7 +5,8 @@
using namespace pimoroni;
BreakoutLTR559 ltr559;
I2C i2c(4, 5);
BreakoutLTR559 ltr559(&i2c);
int main() {
stdio_init_all();

3
examples/breakout_matrix11x7/demo.cpp
Wyświetl plik

@ -4,7 +4,8 @@
using namespace pimoroni;
BreakoutMatrix11x7 matrix11x7(0x75);
I2C i2c(BOARD::BREAKOUT_GARDEN);
BreakoutMatrix11x7 matrix11x7(&i2c, 0x75);
int main() {
gpio_init(PICO_DEFAULT_LED_PIN);

4
examples/breakout_msa301/demo.cpp
Wyświetl plik

@ -1,11 +1,13 @@
#include <stdio.h>
#include "pico/stdlib.h"
#include "common/pimoroni_common.hpp"
#include "breakout_msa301.hpp"
using namespace pimoroni;
BreakoutMSA301 msa301;
I2C i2c(BOARD::BREAKOUT_GARDEN);
BreakoutMSA301 msa301(&i2c);
int main() {
stdio_init_all();

4
examples/breakout_potentiometer/demo.cpp
Wyświetl plik

@ -1,12 +1,14 @@
#include "pico/stdlib.h"
#include <stdio.h>
#include <math.h>
#include "common/pimoroni_common.hpp"
#include "breakout_potentiometer.hpp"
using namespace pimoroni;
BreakoutPotentiometer pot;
I2C i2c(BOARD::BREAKOUT_GARDEN);
BreakoutPotentiometer pot(&i2c);
bool toggle = false;
// HSV Conversion expects float inputs in the range of 0.00-1.00 for each channel

3
examples/breakout_rgbmatrix5x5/demo.cpp
Wyświetl plik

@ -7,7 +7,8 @@
using namespace pimoroni;
BreakoutRGBMatrix5x5 rgbmatrix5x5;
I2C i2c(BOARD::BREAKOUT_GARDEN);
BreakoutRGBMatrix5x5 rgbmatrix5x5(&i2c);
int main() {
rgbmatrix5x5.init();

2
examples/breakout_rtc/CMakeLists.txt
Wyświetl plik

@ -7,7 +7,7 @@ add_executable(
# enable usb output, disable uart output
pico_enable_stdio_usb(${OUTPUT_NAME} 1)
pico_enable_stdio_uart(${OUTPUT_NAME} 0)
pico_enable_stdio_uart(${OUTPUT_NAME} 1)
# Pull in pico libraries that we need
target_link_libraries(${OUTPUT_NAME} pico_stdlib breakout_rtc)

7
examples/breakout_rtc/demo.cpp
Wyświetl plik

@ -4,7 +4,8 @@
using namespace pimoroni;
BreakoutRTC rtc;
I2C i2c(BOARD::BREAKOUT_GARDEN);
BreakoutRTC rtc(&i2c);
int main() {
stdio_init_all();
@ -15,10 +16,10 @@ int main() {
if(!rtc.init()) {
printf("Init failed! Check your connections and i2c pin choices.\n");
}
// rtc.setup(false);
//rtc.setup(false);
// Uncomment the below line on first run to set the RTC date and time to the program's compiler time
// rtc.set_to_compiler_time();
//rtc.set_to_compiler_time();
// Make sure we have 24-hour time
if(rtc.is_12_hour())

3
examples/breakout_sgp30/demo.cpp
Wyświetl plik

@ -13,7 +13,8 @@
using namespace pimoroni;
BreakoutSGP30 sgp30;
I2C i2c(BOARD::BREAKOUT_GARDEN);
BreakoutSGP30 sgp30(&i2c);
int main() {
uint8_t prd;

2
libraries/breakout_colourlcd160x80/breakout_colourlcd160x80.hpp
Wyświetl plik

@ -2,7 +2,7 @@
#include "drivers/st7735/st7735.hpp"
#include "libraries/pico_graphics/pico_graphics.hpp"
#include "common/pimoroni.hpp"
#include "common/pimoroni_common.hpp"
namespace pimoroni {

2
libraries/breakout_colourlcd240x240/breakout_colourlcd240x240.hpp
Wyświetl plik

@ -2,7 +2,7 @@
#include "drivers/st7789/st7789.hpp"
#include "libraries/pico_graphics/pico_graphics.hpp"
#include "common/pimoroni.hpp"
#include "common/pimoroni_common.hpp"
namespace pimoroni {

4
libraries/breakout_encoder/breakout_encoder.hpp
Wyświetl plik

@ -1,6 +1,7 @@
#pragma once
#include "drivers/ioexpander/ioexpander.hpp"
#include "common/pimoroni_common.hpp"
namespace pimoroni {
@ -59,6 +60,9 @@ namespace pimoroni {
BreakoutEncoder(uint8_t address) :
ioe(address) {}
BreakoutEncoder(I2C *i2c, uint8_t address = DEFAULT_I2C_ADDRESS, uint8_t interrupt = PIN_UNUSED, uint32_t timeout = DEFAULT_TIMEOUT, bool debug = false) :
ioe(i2c, address, interrupt, timeout, debug) {}
BreakoutEncoder(i2c_inst_t *i2c, uint8_t address, uint8_t sda, uint8_t scl, uint8_t interrupt = PIN_UNUSED, uint32_t timeout = DEFAULT_TIMEOUT) :
ioe(i2c, address, sda, scl, interrupt, timeout),
interrupt_pin(interrupt) {}

2
libraries/breakout_ltr559/breakout_ltr559.cmake
Wyświetl plik

@ -8,4 +8,4 @@ target_sources(${LIB_NAME} INTERFACE
target_include_directories(${LIB_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(${LIB_NAME} INTERFACE pico_stdlib ltr559)
target_link_libraries(${LIB_NAME} INTERFACE pico_stdlib ltr559 pimoroni_i2c)

10
libraries/breakout_matrix11x7/breakout_matrix11x7.hpp
Wyświetl plik

@ -12,9 +12,13 @@ namespace pimoroni {
bool init();
BreakoutMatrix11x7() : IS31FL3731(DEFAULT_I2C_ADDRESS) {};
BreakoutMatrix11x7(uint8_t address) : IS31FL3731(address) {};
BreakoutMatrix11x7(i2c_inst_t *i2c, uint8_t address, uint8_t sda, uint8_t scl) : IS31FL3731(i2c, address, sda, scl) {};
BreakoutMatrix11x7() : IS31FL3731(new I2C(I2C_BG_SDA, I2C_BG_SCL), DEFAULT_I2C_ADDRESS) {}
BreakoutMatrix11x7(uint8_t address) : IS31FL3731(new I2C(I2C_DEFAULT_SDA, I2C_DEFAULT_SCL), address) {}
BreakoutMatrix11x7(I2C *i2c, uint8_t address = DEFAULT_I2C_ADDRESS) : IS31FL3731(i2c, address) {}
BreakoutMatrix11x7(i2c_inst_t *i2c_inst, uint8_t address, uint8_t sda, uint8_t scl) : IS31FL3731(i2c_inst, address, sda, scl) {}
void set_pixel(uint8_t x, uint8_t y, uint8_t c);

2
libraries/breakout_msa301/breakout_msa301.cmake
Wyświetl plik

@ -8,4 +8,4 @@ target_sources(${LIB_NAME} INTERFACE
target_include_directories(${LIB_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(${LIB_NAME} INTERFACE pico_stdlib msa301)
target_link_libraries(${LIB_NAME} INTERFACE pico_stdlib msa301 pimoroni_i2c)

3
libraries/breakout_potentiometer/breakout_potentiometer.hpp
Wyświetl plik

@ -57,6 +57,9 @@ namespace pimoroni {
BreakoutPotentiometer(uint8_t address) :
ioe(address) {}
BreakoutPotentiometer(I2C *i2c, uint8_t address = DEFAULT_I2C_ADDRESS, uint8_t interrupt = PIN_UNUSED, uint32_t timeout = DEFAULT_TIMEOUT, bool debug = false) :
ioe(i2c, address, interrupt, timeout, debug) {}
BreakoutPotentiometer(i2c_inst_t *i2c, uint8_t address, uint8_t sda, uint8_t scl, uint8_t interrupt = PIN_UNUSED, uint32_t timeout = DEFAULT_TIMEOUT) :
ioe(i2c, address, sda, scl, interrupt, timeout) {}

12
libraries/breakout_rgbmatrix5x5/breakout_rgbmatrix5x5.hpp
Wyświetl plik

@ -18,10 +18,14 @@ namespace pimoroni {
bool init();
void set_pixel(uint8_t x, uint8_t y, uint8_t r, uint8_t g, uint8_t b);
BreakoutRGBMatrix5x5() : IS31FL3731(DEFAULT_I2C_ADDRESS) {};
BreakoutRGBMatrix5x5(uint8_t address) : IS31FL3731(address) {};
BreakoutRGBMatrix5x5(i2c_inst_t *i2c, uint8_t address, uint8_t sda, uint8_t scl) : IS31FL3731(i2c, address, sda, scl) {};
BreakoutRGBMatrix5x5() : IS31FL3731(new I2C(I2C_BG_SDA, I2C_BG_SCL), DEFAULT_I2C_ADDRESS) {}
BreakoutRGBMatrix5x5(uint8_t address) : IS31FL3731(new I2C(I2C_DEFAULT_SDA, I2C_DEFAULT_SCL), address) {}
BreakoutRGBMatrix5x5(I2C *i2c, uint8_t address = DEFAULT_I2C_ADDRESS) : IS31FL3731(i2c, address) {}
BreakoutRGBMatrix5x5(i2c_inst_t *i2c_inst, uint8_t address, uint8_t sda, uint8_t scl) : IS31FL3731(i2c_inst, address, sda, scl) {}
private:
RGBLookup lookup_pixel(uint8_t index);

2
libraries/breakout_sgp30/breakout_sgp30.cmake
Wyświetl plik

@ -8,4 +8,4 @@ target_sources(${LIB_NAME} INTERFACE
target_include_directories(${LIB_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(${LIB_NAME} INTERFACE pico_stdlib hardware_i2c sgp30)
target_link_libraries(${LIB_NAME} INTERFACE pico_stdlib hardware_i2c sgp30 pimoroni_i2c)

2
micropython/modules/micropython.cmake
Wyświetl plik

@ -1,5 +1,7 @@
include_directories(${CMAKE_CURRENT_LIST_DIR}/../../)
include(${CMAKE_CURRENT_LIST_DIR}/pimoroni_i2c/micropython.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/breakout_dotmatrix/micropython.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/breakout_encoder/micropython.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/breakout_ioexpander/micropython.cmake)

17
micropython/modules/pimoroni_i2c/micropython.cmake 100644
Wyświetl plik

@ -0,0 +1,17 @@
set(MOD_NAME pimoroni_i2c)
string(TOUPPER ${MOD_NAME} MOD_NAME_UPPER)
add_library(usermod_${MOD_NAME} INTERFACE)
target_sources(usermod_${MOD_NAME} INTERFACE
${CMAKE_CURRENT_LIST_DIR}/../../../common/pimoroni_i2c.cpp
)
target_include_directories(usermod_${MOD_NAME} INTERFACE
${CMAKE_CURRENT_LIST_DIR}
)
target_compile_definitions(usermod_${MOD_NAME} INTERFACE
-DMODULE_${MOD_NAME_UPPER}_ENABLED=1
)
target_link_libraries(usermod INTERFACE usermod_${MOD_NAME})