Files
lilygo-t-deck/lib/SensorsLib/src/SensorCommon.tpp
T

736 lines
22 KiB
C++

/**
*
* @license MIT License
*
* Copyright (c) 2022 lewis he
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* @file SensorCommon.tpp
* @author Lewis He (lewishe@outlook.com)
* @date 2022-10-16
*
*/
#pragma once
#include "SensorLib.h"
typedef union {
struct {
uint8_t low;
uint8_t high;
} bits;
uint16_t full;
} RegData_t;
typedef int (*iic_fptr_t)(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint8_t len);
typedef void (*gpio_write_fptr_t)(uint32_t gpio, uint8_t value);
typedef int (*gpio_read_fptr_t)(uint32_t gpio);
typedef void (*gpio_mode_fptr_t)(uint32_t gpio, uint8_t mode);
typedef void (*delay_ms_fptr_t)(uint32_t ms);
template <class chipType>
class SensorCommon
{
public:
~SensorCommon()
{
#if defined(ARDUINO)
if (__spiSetting) {
delete __spiSetting;
}
#endif
}
#if defined(ARDUINO)
void setSpiSetting(uint32_t freq, uint8_t dataOrder = SPI_DATA_ORDER, uint8_t dataMode = SPI_MODE0)
{
__freq = freq;
__dataOrder = dataOrder;
__dataMode = dataMode;
}
bool begin(PLATFORM_WIRE_TYPE &w, uint8_t addr, int sda, int scl)
{
log_i("Using Arduino Wire interface.");
if (__has_init)return thisChip().initImpl();
__wire = &w;
__sda = sda;
__scl = scl;
#if defined(NRF52840_XXAA) || defined(NRF52832_XXAA)
if (__sda != 0xFF && __scl != 0xFF) {
__wire->setPins(__sda, __scl);
}
__wire->begin();
#elif defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_STM32)
if (__sda != 0xFF && __scl != 0xFF) {
__wire->end();
__wire->setSDA(__sda);
__wire->setSCL(__scl);
}
__wire->begin();
#elif defined(ARDUINO_ARCH_ESP32)
__wire->begin(__sda, __scl);
#else
__wire->begin();
#endif
__addr = addr;
__spi = NULL;
__i2c_master_read = NULL;
__i2c_master_write = NULL;
__has_init = thisChip().initImpl();
return __has_init;
}
bool begin(int cs, int mosi = -1, int miso = -1, int sck = -1,
PLATFORM_SPI_TYPE &spi = SPI
)
{
log_i("Using Arduino SPI interface.");
if (__has_init)return thisChip().initImpl();
__cs = cs;
__spi = &spi;
pinMode(__cs, OUTPUT);
digitalWrite(__cs, HIGH);
__spiSetting = new DEFAULT_SPISETTING;
if (!__spiSetting) {
return false;
}
if (mosi != -1 && miso != -1 && sck != -1) {
#if defined(NRF52840_XXAA) || defined(NRF52832_XXAA)
__spi->begin();
#elif defined(ARDUINO_ARCH_RP2040)
__spi->setSCK(sck);
__spi->setRX(miso);
__spi->setTX(mosi);
__spi->begin();
#else
__spi->begin(sck, miso, mosi);
#endif
} else {
__spi->begin();
}
__wire = NULL;
__readMask = thisChip().getReadMaskImpl();
__has_init = thisChip().initImpl();
return __has_init;
}
#elif defined(ESP_PLATFORM) && !defined(ARDUINO)
#if ((ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5,0,0)) && defined(CONFIG_SENSORLIB_ESP_IDF_NEW_API))
// * Using the new API of esp-idf 5.x, you need to pass the I2C BUS handle,
// * which is useful when the bus shares multiple devices.
bool begin(i2c_master_bus_handle_t i2c_dev_bus_handle, uint8_t addr)
{
log_i("Using ESP-IDF Driver interface.");
if (i2c_dev_bus_handle == NULL) return false;
if (__has_init)return thisChip().initImpl();
__i2c_master_read = NULL;
__i2c_master_write = NULL;
__addr = addr;
/*
i2c_master_bus_config_t i2c_bus_config;
memset(&i2c_bus_config, 0, sizeof(i2c_bus_config));
i2c_bus_config.clk_source = I2C_CLK_SRC_DEFAULT;
i2c_bus_config.i2c_port = port_num;
i2c_bus_config.scl_io_num = (gpio_num_t)__scl;
i2c_bus_config.sda_io_num = (gpio_num_t)__sda;
i2c_bus_config.glitch_ignore_cnt = 7;
i2c_new_master_bus(&i2c_bus_config, &bus_handle);
*/
bus_handle = i2c_dev_bus_handle;
__i2c_dev_conf.dev_addr_length = I2C_ADDR_BIT_LEN_7;
__i2c_dev_conf.device_address = __addr;
__i2c_dev_conf.scl_speed_hz = SENSORLIB_I2C_MASTER_SEEED;
#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5,3,0))
#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5,4,0))
// New fields since esp-idf-v5.3-beta1
__i2c_dev_conf.scl_wait_us = 0;
#endif
__i2c_dev_conf.flags.disable_ack_check = 0;
#endif
if (ESP_OK != i2c_master_bus_add_device(bus_handle,
&__i2c_dev_conf,
&__i2c_device)) {
log_i("i2c_master_bus_add_device failed !");
return false;
}
log_i("Added Device Address : 0x%X New Dev Address: %p Speed :%lu ", __addr, __i2c_device, __i2c_dev_conf.scl_speed_hz);
__has_init = thisChip().initImpl();
if (!__has_init) {
// Initialization failed, delete device
log_i("i2c_master_bus_rm_device !");
i2c_master_bus_rm_device(__i2c_device);
}
return __has_init;
}
#else //ESP 4.X
bool begin(i2c_port_t port_num, uint8_t addr, int sda, int scl)
{
__i2c_num = port_num;
log_i("Using ESP-IDF Driver interface.");
if (__has_init)return thisChip().initImpl();
__sda = sda;
__scl = scl;
__addr = addr;
__i2c_master_read = NULL;
__i2c_master_write = NULL;
i2c_config_t i2c_conf;
memset(&i2c_conf, 0, sizeof(i2c_conf));
i2c_conf.mode = I2C_MODE_MASTER;
i2c_conf.sda_io_num = sda;
i2c_conf.scl_io_num = scl;
i2c_conf.sda_pullup_en = GPIO_PULLUP_ENABLE;
i2c_conf.scl_pullup_en = GPIO_PULLUP_ENABLE;
i2c_conf.master.clk_speed = SENSORLIB_I2C_MASTER_SEEED;
/**
* @brief Without checking whether the initialization is successful,
* I2C may be initialized externally,
* so just make sure there is an initialization here.
*/
i2c_param_config(__i2c_num, &i2c_conf);
i2c_driver_install(__i2c_num,
i2c_conf.mode,
SENSORLIB_I2C_MASTER_RX_BUF_DISABLE,
SENSORLIB_I2C_MASTER_TX_BUF_DISABLE, 0);
__has_init = thisChip().initImpl();
return __has_init;
}
#endif //ESP 5.X
#endif
bool begin(uint8_t addr, iic_fptr_t readRegCallback, iic_fptr_t writeRegCallback)
{
log_i("Using Custom interface.");
if (__has_init)return thisChip().initImpl();
__i2c_master_read = readRegCallback;
__i2c_master_write = writeRegCallback;
__addr = addr;
#if defined(ARDUINO)
__spi = NULL;
#endif
__has_init = thisChip().initImpl();
return __has_init;
}
void setGpioWriteCallback(gpio_write_fptr_t cb)
{
__set_gpio_level = cb;
}
void setGpioReadCallback(gpio_read_fptr_t cb)
{
__get_gpio_level = cb;
}
void setGpioModeCallback(gpio_mode_fptr_t cb)
{
__set_gpio_mode = cb;
}
void setDelayCallback(delay_ms_fptr_t cb)
{
__delay_ms = cb;
}
protected:
inline void setGpioMode(uint32_t gpio, uint8_t mode)
{
if (__set_gpio_mode) {
return __set_gpio_mode(gpio, mode);
}
#if defined(ARDUINO) || defined(ESP_PLATFORM)
return pinMode(gpio, mode);
#endif
}
inline void setGpioLevel(uint32_t gpio, uint8_t level)
{
if (__set_gpio_level) {
return __set_gpio_level(gpio, level);
}
#if defined(ARDUINO) || defined(ESP_PLATFORM)
return digitalWrite(gpio, level);
#endif
}
inline int getGpioLevel(uint32_t gpio)
{
if (__get_gpio_level) {
return __get_gpio_level(gpio);
}
#if defined(ARDUINO) || defined(ESP_PLATFORM)
return digitalRead(gpio);
#endif
}
bool probe()
{
#if defined(ARDUINO)
if (__wire) {
__wire->beginTransmission(__addr);
return __wire->endTransmission() == 0;
}
return false;
#elif defined(ESP_PLATFORM)
#if ((ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5,0,0)) && defined(CONFIG_SENSORLIB_ESP_IDF_NEW_API))
return i2c_master_probe(bus_handle, __addr, 1000);
#else
return true;
#endif
#else
return true;
#endif
}
//! Write method
int writeRegister(uint8_t reg, uint8_t norVal, uint8_t orVal)
{
int val = readRegister(reg);
if (val == DEV_WIRE_ERR) {
return DEV_WIRE_ERR;
}
val &= norVal;
val |= orVal;
return writeRegister(reg, val);
}
int writeRegister(int reg, uint8_t val)
{
return writeRegister(reg, &val, 1);
}
int writeRegister(int reg, RegData_t data)
{
return writeRegister(reg, (uint8_t *)&data.full, 2);
}
int writeThenRead(uint8_t *write_buffer, size_t write_len, uint8_t *read_buffer, size_t read_len)
{
#if defined(ARDUINO)
if (__wire) {
__wire->beginTransmission(__addr);
__wire->write(write_buffer, write_len);
if (__wire->endTransmission(__sendStop) != 0) {
return DEV_WIRE_ERR;
}
__wire->requestFrom(__addr, read_len);
return __wire->readBytes(read_buffer, read_len) == read_len ? DEV_WIRE_NONE : DEV_WIRE_ERR;
}
#elif defined(ESP_PLATFORM)
#if ((ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5,0,0)) && defined(CONFIG_SENSORLIB_ESP_IDF_NEW_API))
if (ESP_OK == i2c_master_transmit_receive(
__i2c_device,
write_buffer,
write_len,
read_buffer,
read_len,
-1)) {
return DEV_WIRE_NONE;
}
#else //ESP_IDF_VERSION
if (ESP_OK == i2c_master_write_read_device(
__i2c_num,
__addr,
write_buffer,
write_len,
read_buffer,
read_len,
SENSORLIB_I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS)) {
return DEV_WIRE_NONE;
}
#endif //ESP_IDF_VERSION
#endif //ESP_PLATFORM
return DEV_WIRE_ERR;
}
int writeBuffer(uint8_t *buf, size_t length)
{
#if defined(ARDUINO)
if (__wire) {
__wire->beginTransmission(__addr);
__wire->write(buf, length);
uint8_t ret = (__wire->endTransmission());
return ret == 0 ? DEV_WIRE_NONE : DEV_WIRE_ERR;
}
#elif defined(ESP_PLATFORM)
#if ((ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5,0,0)) && defined(CONFIG_SENSORLIB_ESP_IDF_NEW_API))
if (ESP_OK == i2c_master_transmit(
__i2c_device,
buf,
length,
-1)) {
return DEV_WIRE_NONE;
}
#else //ESP_IDF_VERSION
if (ESP_OK == i2c_master_write_to_device(__i2c_num,
__addr,
buf,
length,
SENSORLIB_I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS)) {
return DEV_WIRE_NONE;
}
#endif //ESP_IDF_VERSION
#endif //ESP_PLATFORM
return DEV_WIRE_ERR;
}
int writeRegister(int reg, uint8_t *buf, size_t length)
{
if (__i2c_master_write) {
return __i2c_master_write(__addr, reg, buf, length);
}
#if defined(ARDUINO)
if (__wire) {
__wire->beginTransmission(__addr);
if (__reg_addr_len == 1) {
__wire->write(reg);
} else {
for (int i = 0; i < __reg_addr_len; ++i) {
__wire->write(reg >> (8 * ((__reg_addr_len - 1) - i)));
}
}
__wire->write(buf, length);
return (__wire->endTransmission() == 0) ? DEV_WIRE_NONE : DEV_WIRE_ERR;
}
if (__spi) {
__spi->beginTransaction(*__spiSetting);
digitalWrite(__cs, LOW);
if (__reg_addr_len == 1) {
__spi->transfer(reg);
} else {
for (int i = 0; i < __reg_addr_len; ++i) {
__spi->transfer(reg >> (8 * ((__reg_addr_len - 1) - i)));
}
}
__spi->transfer(buf, length);
digitalWrite(__cs, HIGH);
__spi->endTransaction();
return DEV_WIRE_NONE;
}
return DEV_WIRE_ERR;
#elif defined(ESP_PLATFORM)
uint8_t *write_buffer = (uint8_t *)malloc(sizeof(uint8_t) * (length + __reg_addr_len));
if (!write_buffer) {
return DEV_WIRE_ERR;
}
write_buffer[0] = reg;
memcpy(write_buffer, &reg, __reg_addr_len);
memcpy(write_buffer + __reg_addr_len, buf, length);
int ret = writeBuffer(write_buffer, __reg_addr_len + length);
free(write_buffer);
return ret;
#endif //ESP_PLATFORM
}
//! Read method
int readRegister(int reg)
{
uint8_t val = 0;
return readRegister(reg, &val, 1) == -1 ? -1 : val;
}
int readRegister(int reg, RegData_t *data)
{
return readRegister(reg, (uint8_t *)data, 2);
}
int readRegister(int reg, uint8_t *buf, uint8_t length)
{
if (__i2c_master_read) {
return __i2c_master_read(__addr, reg, buf, length);
}
#if defined(ARDUINO)
if (__wire) {
__wire->beginTransmission(__addr);
if (__reg_addr_len == 1) {
__wire->write(reg);
} else {
for (int i = 0; i < __reg_addr_len; ++i) {
__wire->write(reg >> (8 * ((__reg_addr_len - 1) - i)));
}
}
if (__wire->endTransmission(__sendStop) != 0) {
return DEV_WIRE_ERR;
}
__wire->requestFrom(__addr, length);
return __wire->readBytes(buf, length) == length ? DEV_WIRE_NONE : DEV_WIRE_ERR;
}
if (__spi) {
__spi->beginTransaction(*__spiSetting);
digitalWrite(__cs, LOW);
if (__reg_addr_len == 1) {
__spi->transfer(__readMask != -1 ? (reg | __readMask) : reg);
} else {
uint8_t firstBytes = reg >> (8 * ((__reg_addr_len - 1)));
__spi->transfer(__readMask != -1 ? (firstBytes | __readMask) : firstBytes);
for (int i = 1; i < __reg_addr_len; ++i) {
__spi->transfer(reg >> (8 * ((__reg_addr_len - 1) - i)));
}
}
for (size_t i = 0; i < length; i++) {
buf[i] = __spi->transfer(0x00);
}
digitalWrite(__cs, HIGH);
__spi->endTransaction();
return DEV_WIRE_NONE;
}
#elif defined(ESP_PLATFORM)
#if ((ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5,0,0)) && defined(CONFIG_SENSORLIB_ESP_IDF_NEW_API))
if (ESP_OK == i2c_master_transmit_receive(
__i2c_device,
(const uint8_t *)&reg,
__reg_addr_len,
buf,
length,
-1)) {
return DEV_WIRE_NONE;
}
#else //ESP_IDF_VERSION
if (ESP_OK == i2c_master_write_read_device(__i2c_num,
__addr,
(uint8_t *)&reg,
__reg_addr_len,
buf,
length,
SENSORLIB_I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS)) {
return DEV_WIRE_NONE;
}
#endif //ESP_IDF_VERSION
#endif //ESP_PLATFORM
return DEV_WIRE_ERR;
}
bool inline clrRegisterBit(int registers, uint8_t bit)
{
int val = readRegister(registers);
if (val == DEV_WIRE_ERR) {
return false;
}
return writeRegister(registers, (val & (~_BV(bit)))) == 0;
}
bool inline setRegisterBit(int registers, uint8_t bit)
{
int val = readRegister(registers);
if (val == DEV_WIRE_ERR) {
return false;
}
return writeRegister(registers, (val | (_BV(bit)))) == 0;
}
bool inline getRegisterBit(int registers, uint8_t bit)
{
int val = readRegister(registers);
if (val == DEV_WIRE_ERR) {
return false;
}
return val & _BV(bit);
}
uint16_t inline readRegisterH8L4(uint8_t highReg, uint8_t lowReg)
{
int h8 = readRegister(highReg);
int l4 = readRegister(lowReg);
if (h8 == DEV_WIRE_ERR || l4 == DEV_WIRE_ERR)return 0;
return (h8 << 4) | (l4 & 0x0F);
}
uint16_t inline readRegisterH8L5(uint8_t highReg, uint8_t lowReg)
{
int h8 = readRegister(highReg);
int l5 = readRegister(lowReg);
if (h8 == DEV_WIRE_ERR || l5 == DEV_WIRE_ERR)return 0;
return (h8 << 5) | (l5 & 0x1F);
}
uint16_t inline readRegisterH6L8(uint8_t highReg, uint8_t lowReg)
{
int h6 = readRegister(highReg);
int l8 = readRegister(lowReg);
if (h6 == DEV_WIRE_ERR || l8 == DEV_WIRE_ERR)return 0;
return ((h6 & 0x3F) << 8) | l8;
}
uint16_t inline readRegisterH5L8(uint8_t highReg, uint8_t lowReg)
{
int h5 = readRegister(highReg);
int l8 = readRegister(lowReg);
if (h5 == DEV_WIRE_ERR || l8 == DEV_WIRE_ERR)return 0;
return ((h5 & 0x1F) << 8) | l8;
}
void setRegAddressLength(uint8_t len)
{
__reg_addr_len = len;
}
void setReadRegisterSendStop(bool sendStop)
{
__sendStop = sendStop;
}
bool reallocBuffer(size_t realloc_size)
{
#if defined(ARDUINO)
#ifdef ARDUINO_ARCH_ESP32
// ESP32 I2C BUFFER : 128 Bytes
if (__wire) {
if (__wire->setBufferSize(realloc_size) != realloc_size) {
log_e("realloc I2C buffer failed!");
return false;
}
}
#elif defined(ARDUINO_ARCH_RP2040)
// RP2040 I2C BUFFER : 256 Bytes
#elif defined(ARDUINO_ARCH_NRF52)
// NRF52840 I2C BUFFER : 64 Bytes
// #warning "NRF Platform I2C Buffer expansion is not implemented"
//TODO:"NRF Platform I2C Buffer expansion is not implemented"
#endif
#endif
return true;
}
/*
* CRTP Helper
*/
protected:
// bool begin()
// {
// #if defined(ARDUINO)
// if (__has_init) return thisChip().initImpl();
// __has_init = true;
// if (__wire) {
// log_i("SDA:%d SCL:%d", __sda, __scl);
// #if defined(NRF52840_XXAA) || defined(NRF52832_XXAA)
// __wire->begin();
// #elif defined(ARDUINO_ARCH_RP2040)
// __wire->end();
// __wire->setSDA(__sda);
// __wire->setSCL(__scl);
// __wire->begin();
// #else
// __wire->begin(__sda, __scl);
// #endif
// }
// if (__spi) {
// // int cs, int mosi = -1, int miso = -1, int sck = -1, SPIClass &spi = SPI
// begin(__cs, __mosi, __miso, __sck, *__spi);
// }
// #endif /*ARDUINO*/
// return thisChip().initImpl();
// }
void end()
{
#if defined(ARDUINO)
if (__wire) {
#if defined(ESP_IDF_VERSION)
#if ESP_IDF_VERSION > ESP_IDF_VERSION_VAL(4,4,0)
__wire->end();
#endif /*ESP_IDF_VERSION*/
#endif /*ESP_IDF_VERSION*/
}
#endif /*ARDUINO*/
}
inline const chipType &thisChip() const
{
return static_cast<const chipType &>(*this);
}
inline chipType &thisChip()
{
return static_cast<chipType &>(*this);
}
protected:
bool __has_init = false;
#if defined(ARDUINO)
PLATFORM_WIRE_TYPE *__wire = NULL;
PLATFORM_SPI_TYPE *__spi = NULL;
SPISettings *__spiSetting = NULL;
uint8_t __dataOrder = SPI_DATA_ORDER;
uint8_t __dataMode = SPI_MODE0;
uint32_t __freq = 400000;
#elif defined(ESP_PLATFORM)
i2c_port_t __i2c_num;
#if ((ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5,0,0)) && defined(CONFIG_SENSORLIB_ESP_IDF_NEW_API))
i2c_master_bus_handle_t bus_handle;
i2c_master_dev_handle_t __i2c_device;
i2c_device_config_t __i2c_dev_conf;
#endif //ESP_IDF_VERSION
#endif //ESP_PLATFORM
int __readMask = -1;
int __sda = -1;
int __scl = -1;
int __cs = -1;
int __miso = -1;
int __mosi = -1;
int __sck = -1;
bool __sendStop = true;
uint8_t __addr = 0xFF;
uint8_t __reg_addr_len = 1;
iic_fptr_t __i2c_master_read = NULL;
iic_fptr_t __i2c_master_write = NULL;
gpio_write_fptr_t __set_gpio_level = NULL;
gpio_read_fptr_t __get_gpio_level = NULL;
gpio_mode_fptr_t __set_gpio_mode = NULL;
delay_ms_fptr_t __delay_ms = NULL;
};