/** * * @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 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_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_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_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(*this); } inline chipType &thisChip() { return static_cast(*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; };