diff --git a/examples/cxx/experimental/experimental_cpp_component/CMakeLists.txt b/examples/cxx/experimental/experimental_cpp_component/CMakeLists.txt index db45ae32e1..858e1c114b 100644 --- a/examples/cxx/experimental/experimental_cpp_component/CMakeLists.txt +++ b/examples/cxx/experimental/experimental_cpp_component/CMakeLists.txt @@ -1,2 +1,3 @@ -idf_component_register(SRCS "esp_exception.cpp" - INCLUDE_DIRS "include") +idf_component_register(SRCS "esp_exception.cpp" "i2c_cxx.cpp" + INCLUDE_DIRS "include" + REQUIRES driver) diff --git a/examples/cxx/experimental/experimental_cpp_component/component.mk b/examples/cxx/experimental/experimental_cpp_component/component.mk index e69de29bb2..3e0b3af925 100644 --- a/examples/cxx/experimental/experimental_cpp_component/component.mk +++ b/examples/cxx/experimental/experimental_cpp_component/component.mk @@ -0,0 +1,4 @@ +COMPONENT_ADD_INCLUDEDIRS := include + +COMPONENT_SRCDIRS := ./ driver + diff --git a/examples/cxx/experimental/experimental_cpp_component/esp_exception.cpp b/examples/cxx/experimental/experimental_cpp_component/esp_exception.cpp index 1136529270..dce4b0ed6c 100644 --- a/examples/cxx/experimental/experimental_cpp_component/esp_exception.cpp +++ b/examples/cxx/experimental/experimental_cpp_component/esp_exception.cpp @@ -1,3 +1,17 @@ +// Copyright 2020 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + #ifdef __cpp_exceptions #include "esp_exception.hpp" diff --git a/examples/cxx/experimental/experimental_cpp_component/i2c_cxx.cpp b/examples/cxx/experimental/experimental_cpp_component/i2c_cxx.cpp new file mode 100644 index 0000000000..332ae0b08b --- /dev/null +++ b/examples/cxx/experimental/experimental_cpp_component/i2c_cxx.cpp @@ -0,0 +1,201 @@ +// Copyright 2020 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifdef __cpp_exceptions + +#include "i2c_cxx.hpp" + +using namespace std; + +namespace idf { + +#define I2C_CHECK_THROW(err) CHECK_THROW_SPECIFIC((err), I2CException) + +I2CException::I2CException(esp_err_t error) : ESPException(error) { } + +I2CTransferException::I2CTransferException(esp_err_t error) : I2CException(error) { } + +I2CBus::I2CBus(i2c_port_t i2c_number) : i2c_num(i2c_number) { } + +I2CBus::~I2CBus() { } + +I2CMaster::I2CMaster(i2c_port_t i2c_number, + int scl_gpio, + int sda_gpio, + uint32_t clock_speed, + bool scl_pullup, + bool sda_pullup) + : I2CBus(i2c_number) +{ + i2c_config_t conf = {}; + conf.mode = I2C_MODE_MASTER; + conf.scl_io_num = scl_gpio; + conf.scl_pullup_en = scl_pullup; + conf.sda_io_num = sda_gpio; + conf.sda_pullup_en = sda_pullup; + conf.master.clk_speed = clock_speed; + I2C_CHECK_THROW(i2c_param_config(i2c_num, &conf)); + I2C_CHECK_THROW(i2c_driver_install(i2c_num, conf.mode, 0, 0, 0)); +} + +I2CMaster::~I2CMaster() +{ + i2c_driver_delete(i2c_num); +} + +void I2CMaster::sync_write(uint8_t i2c_addr, const vector &data) +{ + I2CWrite writer(data); + + writer.do_transfer(i2c_num, i2c_addr); +} + +std::vector I2CMaster::sync_read(uint8_t i2c_addr, size_t n_bytes) +{ + I2CRead reader(n_bytes); + + return reader.do_transfer(i2c_num, i2c_addr); +} + +vector I2CMaster::sync_transfer(uint8_t i2c_addr, + const std::vector &write_data, + size_t read_n_bytes) +{ + if (!read_n_bytes) throw I2CException(ESP_ERR_INVALID_ARG); + + I2CComposed composed_transfer; + composed_transfer.add_write(write_data); + composed_transfer.add_read(read_n_bytes); + + return composed_transfer.do_transfer(i2c_num, i2c_addr)[0]; +} + +I2CSlave::I2CSlave(i2c_port_t i2c_number, + int scl_gpio, + int sda_gpio, + uint8_t slave_addr, + size_t rx_buf_len, + size_t tx_buf_len, + bool scl_pullup, + bool sda_pullup) + : I2CBus(i2c_number) +{ + i2c_config_t conf = {}; + conf.mode = I2C_MODE_SLAVE; + conf.scl_io_num = scl_gpio; + conf.scl_pullup_en = scl_pullup; + conf.sda_io_num = sda_gpio; + conf.sda_pullup_en = sda_pullup; + conf.slave.addr_10bit_en = 0; + conf.slave.slave_addr = slave_addr; + I2C_CHECK_THROW(i2c_param_config(i2c_num, &conf)); + I2C_CHECK_THROW(i2c_driver_install(i2c_num, conf.mode, rx_buf_len, tx_buf_len, 0)); +} + +I2CSlave::~I2CSlave() +{ + i2c_driver_delete(i2c_num); +} + +int I2CSlave::write_raw(const uint8_t *data, size_t data_len, chrono::milliseconds timeout) +{ + return i2c_slave_write_buffer(i2c_num, data, data_len, (TickType_t) timeout.count() / portTICK_RATE_MS); +} + +int I2CSlave::read_raw(uint8_t *buffer, size_t buffer_len, chrono::milliseconds timeout) +{ + return i2c_slave_read_buffer(i2c_num, buffer, buffer_len, (TickType_t) timeout.count() / portTICK_RATE_MS); +} + +I2CWrite::I2CWrite(const vector &bytes, chrono::milliseconds driver_timeout) + : I2CTransfer(driver_timeout), bytes(bytes) { } + +void I2CWrite::queue_cmd(i2c_cmd_handle_t handle, uint8_t i2c_addr) +{ + I2C_CHECK_THROW(i2c_master_start(handle)); + I2C_CHECK_THROW(i2c_master_write_byte(handle, i2c_addr << 1 | I2C_MASTER_WRITE, true)); + I2C_CHECK_THROW(i2c_master_write(handle, bytes.data(), bytes.size(), true)); +} + +void I2CWrite::process_result() { } + +I2CRead::I2CRead(size_t size, chrono::milliseconds driver_timeout) + : I2CTransfer >(driver_timeout), bytes(size) { } + +void I2CRead::queue_cmd(i2c_cmd_handle_t handle, uint8_t i2c_addr) +{ + I2C_CHECK_THROW(i2c_master_start(handle)); + I2C_CHECK_THROW(i2c_master_write_byte(handle, i2c_addr << 1 | I2C_MASTER_READ, true)); + I2C_CHECK_THROW(i2c_master_read(handle, bytes.data(), bytes.size(), I2C_MASTER_LAST_NACK)); +} + +vector I2CRead::process_result() +{ + return bytes; +} + +I2CComposed::I2CComposed(chrono::milliseconds driver_timeout) + : I2CTransfer > >(driver_timeout), transfer_list() { } + +void I2CComposed::CompTransferNodeRead::queue_cmd(i2c_cmd_handle_t handle, uint8_t i2c_addr) +{ + I2C_CHECK_THROW(i2c_master_write_byte(handle, i2c_addr << 1 | I2C_MASTER_READ, true)); + I2C_CHECK_THROW(i2c_master_read(handle, bytes.data(), bytes.size(), I2C_MASTER_LAST_NACK)); +} + +void I2CComposed::CompTransferNodeRead::process_result(std::vector > &read_results) +{ + read_results.push_back(bytes); +} + +void I2CComposed::CompTransferNodeWrite::queue_cmd(i2c_cmd_handle_t handle, uint8_t i2c_addr) +{ + I2C_CHECK_THROW(i2c_master_write_byte(handle, i2c_addr << 1 | I2C_MASTER_WRITE, true)); + I2C_CHECK_THROW(i2c_master_write(handle, bytes.data(), bytes.size(), true)); +} + +void I2CComposed::add_read(size_t size) +{ + if (!size) throw I2CException(ESP_ERR_INVALID_ARG); + + transfer_list.push_back(make_shared(size)); +} + +void I2CComposed::add_write(std::vector bytes) +{ + if (bytes.empty()) throw I2CException(ESP_ERR_INVALID_ARG); + + transfer_list.push_back(make_shared(bytes)); +} + +void I2CComposed::queue_cmd(i2c_cmd_handle_t handle, uint8_t i2c_addr) +{ + for (auto it = transfer_list.begin(); it != transfer_list.end(); it++) { + I2C_CHECK_THROW(i2c_master_start(handle)); + (*it)->queue_cmd(handle, i2c_addr); + } +} + +std::vector > I2CComposed::process_result() +{ + std::vector > results; + for (auto it = transfer_list.begin(); it != transfer_list.end(); it++) { + (*it)->process_result(results); + } + return results; +} + +} // idf + +#endif // __cpp_exceptions diff --git a/examples/cxx/experimental/experimental_cpp_component/include/esp_exception.hpp b/examples/cxx/experimental/experimental_cpp_component/include/esp_exception.hpp index 7a68078ae6..1c59564889 100644 --- a/examples/cxx/experimental/experimental_cpp_component/include/esp_exception.hpp +++ b/examples/cxx/experimental/experimental_cpp_component/include/esp_exception.hpp @@ -12,8 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#ifndef ESP_EXCEPTION_HPP_ -#define ESP_EXCEPTION_HPP_ +#pragma once #ifdef __cpp_exceptions @@ -35,10 +34,21 @@ struct ESPException : public std::exception { /** * Convenience macro to help converting IDF error codes into ESPException. */ -#define CHECK_THROW(error_) if (error_ != ESP_OK) throw idf::ESPException(error_); +#define CHECK_THROW(error_) \ + do { \ + esp_err_t result = error_; \ + if (result != ESP_OK) throw idf::ESPException(result); \ + } while (0) + +/** + * Convenience macro to help converting IDF error codes into a child of ESPException. + */ +#define CHECK_THROW_SPECIFIC(error_, exception_type_) \ + do { \ + esp_err_t result = error_; \ + if (result != ESP_OK) throw idf::exception_type_(result); \ + } while (0) } // namespace idf #endif // __cpp_exceptions - -#endif // ESP_EXCEPTION_HPP_ diff --git a/examples/cxx/experimental/experimental_cpp_component/include/i2c_cxx.hpp b/examples/cxx/experimental/experimental_cpp_component/include/i2c_cxx.hpp new file mode 100644 index 0000000000..d850fe77d8 --- /dev/null +++ b/examples/cxx/experimental/experimental_cpp_component/include/i2c_cxx.hpp @@ -0,0 +1,494 @@ +// Copyright 2020 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once + +#ifndef __cpp_exceptions +#error I2C class can only be used when __cpp_exceptions is enabled. Enable CONFIG_COMPILER_CXX_EXCEPTIONS in Kconfig +#endif + +#include +#include +#include +#include +#include +#include + +#include "driver/i2c.h" +#include "esp_exception.hpp" + +namespace idf { + +struct I2CException : public ESPException { + I2CException(esp_err_t error); +}; + +struct I2CTransferException : public I2CException { + I2CTransferException(esp_err_t error); +}; + +/** + * Superclass for all transfer objects which are accepted by \c I2CMaster::transfer(). + */ +template +class I2CTransfer { +protected: + /** + * Wrapper around i2c_cmd_handle_t, makes it exception-safe. + */ + struct I2CCommandLink { + I2CCommandLink(); + ~I2CCommandLink(); + + i2c_cmd_handle_t handle; + }; + +public: + /** + * Helper typedef to facilitate type resolution during calls to I2CMaster::transfer(). + */ + typedef TReturn TransferReturnT; + + /** + * @param driver_timeout The timeout used for calls like i2c_master_cmd_begin() to the underlying driver. + */ + I2CTransfer(std::chrono::milliseconds driver_timeout = std::chrono::milliseconds(1000)); + + virtual ~I2CTransfer() { } + + /** + * Do all general parts of the I2C transfer: + * - initialize the command link + * - issuing a start to the command link queue + * - calling \c queue_cmd() in the subclass to issue specific commands to the command link queue + * - issuing a stop to the command link queue + * - executing the assembled commands on the I2C bus + * - calling \c process_result() to process the results of the commands or calling process_exception() if + * there was an exception + * - deleting the command link + * This method is normally called by I2CMaster, but can also be used stand-alone if the bus corresponding to + * \c i2c_num has be initialized. + * + * @throws I2CException for any particular I2C error + */ + TReturn do_transfer(i2c_port_t i2c_num, uint8_t i2c_addr); + +protected: + /** + * Implementation of the I2C command is implemented by subclasses. + * The I2C command handle is initialized already at this stage. + * The first action is issuing the I2C address and the read/write bit, depending on what the subclass implements. + * On error, this method has to throw an instance of I2CException. + * + * @param handle the initialized command handle of the I2C driver. + * @param i2c_addr The slave's I2C address. + * + * @throw I2CException + */ + virtual void queue_cmd(i2c_cmd_handle_t handle, uint8_t i2c_addr) = 0; + + /** + * Implementation of whatever neccessary action after successfully sending the I2C command. + * On error, this method has to throw an instance of I2CException. + * + * @throw I2CException + */ + virtual TReturn process_result() = 0; + + /** + * For some calls to the underlying driver (e.g. \c i2c_master_cmd_begin() ), this general timeout will be passed. + */ + const TickType_t driver_timeout; +}; + +/** + * @brief Super class for any I2C master or slave + */ +class I2CBus { +public: + /* + * @brief Initialize I2C master bus. + * + * Initialize and install the bus driver in master mode. + * + * @param i2c_number The I2C port number. + */ + I2CBus(i2c_port_t i2c_number); + + /** + * @brief uninstall the bus driver. + */ + virtual ~I2CBus(); + + /** + * The I2C port number. + */ + const i2c_port_t i2c_num; +}; + +/** + * @brief Simple I2C Master object + * + * This class provides to ways to issue I2C read and write requests. The simplest way is to use \c sync_write() and + * sync_read() to write and read, respectively. As the name suggests, they block during the whole transfer. + * For all asynchrounous transfers as well as combined write-read transfers, use \c transfer(). + */ +class I2CMaster : public I2CBus { +public: + /** + * Initialize and install the driver of an I2C master peripheral. + * + * Initialize and install the bus driver in master mode. Pullups will be enabled for both pins. If you want a + * different configuration, use configure() and i2c_set_pin() of the underlying driver to disable one or both + * pullups. + * + * @param i2c_number The number of the I2C device. + * @param scl_gpio GPIO number of the SCL line. + * @param sda_gpio GPIO number of the SDA line. + * @param clock_speed The master clock speed. + * @param scl_pullup Enable SCL pullup. + * @param sda_pullup Enable SDA pullup. + * + * @throws I2CException with the corrsponding esp_err_t return value if something goes wrong + */ + I2CMaster(i2c_port_t i2c_number, + int scl_gpio, + int sda_gpio, + uint32_t clock_speed, + bool scl_pullup = true, + bool sda_pullup = true); + + /** + * Delete the driver. + */ + virtual ~I2CMaster(); + + /** + * Issue an asynchronous I2C transfer which is executed in the background. + * + * This method uses a C++ \c std::future as mechanism to wait for the asynchronous return value. + * The return value can be accessed with \c future::get(). \c future::get() also synchronizes with the thread + * doing the work in the background, i.e. it waits until the return value has been issued. + * + * The actual implementation is delegated to the TransferT object. It will be given the I2C number to work + * with. + * + * Requirements for TransferT: It should implement or imitate the interface of I2CTransfer. + * + * @param xfer The transfer to execute. What the transfer does, depends on it's implementation in + * \c TransferT::do_transfer(). It also determines the future template of this function, indicated by + * \c TransferT::TransferReturnT. + * + * @param i2c_addr The address of the I2C slave device targeted by the transfer. + * + * @return A future with \c TransferT::TransferReturnT. It depends on which template type is used for xfer. + * In case of a simple write (I2CWrite), it's future. + * In case of a read (I2CRead), it's future > corresponding to the length of the read + * operation. + * If TransferT is a combined transfer with repeated reads (I2CComposed), then the return type is + * future > >, a vector of results corresponding to the queued read operations. + * + * @throws I2CException with the corrsponding esp_err_t return value if something goes wrong + * @throws std::exception for failures in libstdc++ + */ + template + std::future transfer(std::shared_ptr xfer, uint8_t i2c_addr); + + /** + * Do a synchronous write. + * + * All data in data will be written to the I2C device with i2c_addr at once. + * This method will block until the I2C write is complete. + * + * @param i2c_addr The address of the I2C device to which the data shall be sent. + * @param data The data to send (size to be sent is determined by data.size()). + * + * @throws I2CException with the corrsponding esp_err_t return value if something goes wrong + * @throws std::exception for failures in libstdc++ + */ + void sync_write(uint8_t i2c_addr, const std::vector &data); + + /** + * Do a synchronous read. + * This method will block until the I2C read is complete. + * + * n_bytes bytes of data will be read from the I2C device with i2c_addr. + * While reading the last byte, the master finishes the reading by sending a NACK, before issuing a stop. + * + * @param i2c_addr The address of the I2C device from which to read. + * @param n_bytes The number of bytes to read. + * + * @return the read bytes + * + * @throws I2CException with the corrsponding esp_err_t return value if something goes wrong + * @throws std::exception for failures in libstdc++ + */ + std::vector sync_read(uint8_t i2c_addr, size_t n_bytes); + + /** + * Do a simple asynchronous write-read transfer. + * + * First, \c write_data will be written to the bus, then a number of \c read_n_bytes will be read from the bus + * with a repeated start condition. The slave device is determined by \c i2c_addr. + * While reading the last byte, the master finishes the reading by sending a NACK, before issuing a stop. + * This method will block until the I2C transfer is complete. + * + * @param i2c_addr The address of the I2C device from which to read. + * @param write_data The data to write to the bus before reading. + * @param read_n_bytes The number of bytes to read. + * + * @return the read bytes + * + * @throws I2CException with the corrsponding esp_err_t return value if something goes wrong + * @throws std::exception for failures in libstdc++ + */ + std::vector sync_transfer(uint8_t i2c_addr, + const std::vector &write_data, + size_t read_n_bytes); +}; + +/** + * @brief Responsible for initialization and de-initialization of an I2C slave peripheral. + */ +class I2CSlave : public I2CBus { +public: + /** + * Initialize and install the driver of an I2C slave peripheral. + * + * Initialize and install the bus driver in slave mode. Pullups will be enabled for both pins. If you want a + * different configuration, use configure() and i2c_set_pin() of the underlying driver to disable one or both + * pullups. + * + * @param i2c_number The number of the I2C device. + * @param scl_gpio GPIO number of the SCL line. + * @param sda_gpio GPIO number of the SDA line. + * @param slave_addr The address of the slave device on the I2C bus. + * @param rx_buf_len Receive buffer length. + * @param tx_buf_len Transmit buffer length. + * @param scl_pullup Enable SCL pullup. + * @param sda_pullup Enable SDA pullup. + * + * @throws + */ + I2CSlave(i2c_port_t i2c_number, + int scl_gpio, + int sda_gpio, + uint8_t slave_addr, + size_t rx_buf_len, + size_t tx_buf_len, + bool scl_pullup = true, + bool sda_pullup = true); + + /** + * Delete the driver. + */ + virtual ~I2CSlave(); + + /** + * Schedule a raw data write once master is ready. + * + * The data is saved in a buffer, waiting for the master to pick it up. + */ + virtual int write_raw(const uint8_t* data, size_t data_len, std::chrono::milliseconds timeout); + + /** + * Read raw data from the bus. + * + * The data is read directly from the buffer. Hence, it has to be written already by master. + */ + virtual int read_raw(uint8_t* buffer, size_t buffer_len, std::chrono::milliseconds timeout); +}; + +/** + * Implementation for simple I2C writes, which can be executed by \c I2CMaster::transfer(). + * It stores the bytes to be written as a vector. + */ +class I2CWrite : public I2CTransfer { +public: + /** + * @param bytes The bytes which should be written. + * @param driver_timeout The timeout used for calls like i2c_master_cmd_begin() to the underlying driver. + */ + I2CWrite(const std::vector &bytes, std::chrono::milliseconds driver_timeout = std::chrono::milliseconds(1000)); + +protected: + /** + * Write the address and set the read bit to 0 to issue the address and request a write. + * Then write the bytes. + * + * @param handle The initialized I2C command handle. + * @param i2c_addr The I2C address of the slave. + */ + void queue_cmd(i2c_cmd_handle_t handle, uint8_t i2c_addr) override; + + /** + * Set the value of the promise to unblock any callers waiting on it. + */ + void process_result() override; + +private: + /** + * The bytes to write. + */ + std::vector bytes; +}; + +/** + * Implementation for simple I2C reads, which can be executed by \c I2CMaster::transfer(). + * It stores the bytes to be read as a vector to be returned later via a future. + */ +class I2CRead : public I2CTransfer > { +public: + /** + * @param The number of bytes to read. + * @param driver_timeout The timeout used for calls like i2c_master_cmd_begin() to the underlying driver. + */ + I2CRead(size_t size, std::chrono::milliseconds driver_timeout = std::chrono::milliseconds(1000)); + +protected: + /** + * Write the address and set the read bit to 1 to issue the address and request a read. + * Then read into bytes. + * + * @param handle The initialized I2C command handle. + * @param i2c_addr The I2C address of the slave. + */ + void queue_cmd(i2c_cmd_handle_t handle, uint8_t i2c_addr) override; + + /** + * Set the return value of the promise to unblock any callers waiting on it. + */ + std::vector process_result() override; + +private: + /** + * The bytes to read. + */ + std::vector bytes; +}; + +/** + * This kind of transfer uses repeated start conditions to chain transfers coherently. + * In particular, this can be used to chain multiple single write and read transfers into a single transfer with + * repeated starts as it is commonly done for I2C devices. + * The result is a vector of vectors representing the reads in the order of how they were added using add_read(). + */ +class I2CComposed : public I2CTransfer > > { +public: + I2CComposed(std::chrono::milliseconds driver_timeout = std::chrono::milliseconds(1000)); + + /** + * Add a read to the chain. + * + * @param size The size of the read in bytes. + */ + void add_read(size_t size); + + /** + * Add a write to the chain. + * + * @param bytes The bytes to write; size will be bytes.size() + */ + void add_write(std::vector bytes); + +protected: + /** + * Write all chained transfers, including a repeated start issue after each but the last transfer. + * + * @param handle The initialized I2C command handle. + * @param i2c_addr The I2C address of the slave. + */ + void queue_cmd(i2c_cmd_handle_t handle, uint8_t i2c_addr) override; + + /** + * Creates the vector with the vectors from all reads. + */ + std::vector > process_result() override; + +private: + class CompTransferNode { + public: + virtual void queue_cmd(i2c_cmd_handle_t handle, uint8_t i2c_addr) = 0; + virtual void process_result(std::vector > &read_results) { } + }; + + class CompTransferNodeRead : public CompTransferNode { + public: + CompTransferNodeRead(size_t size) : bytes(size) { } + void queue_cmd(i2c_cmd_handle_t handle, uint8_t i2c_addr) override; + + void process_result(std::vector > &read_results) override; + private: + std::vector bytes; + }; + + class CompTransferNodeWrite : public CompTransferNode { + public: + CompTransferNodeWrite(std::vector bytes) : bytes(bytes) { } + void queue_cmd(i2c_cmd_handle_t handle, uint8_t i2c_addr) override; + private: + std::vector bytes; + }; + + /** + * The chained transfers. + */ + std::list > transfer_list; +}; + +template +I2CTransfer::I2CTransfer(std::chrono::milliseconds driver_timeout) + : driver_timeout(driver_timeout.count()) { } + +template +I2CTransfer::I2CCommandLink::I2CCommandLink() +{ + handle = i2c_cmd_link_create(); + if (!handle) { + throw I2CException(ESP_ERR_NO_MEM); + } +} + +template +I2CTransfer::I2CCommandLink::~I2CCommandLink() +{ + i2c_cmd_link_delete(handle); +} + +template +TReturn I2CTransfer::do_transfer(i2c_port_t i2c_num, uint8_t i2c_addr) +{ + I2CCommandLink cmd_link; + + queue_cmd(cmd_link.handle, i2c_addr); + + CHECK_THROW_SPECIFIC(i2c_master_stop(cmd_link.handle), I2CException); + + CHECK_THROW_SPECIFIC(i2c_master_cmd_begin(i2c_num, cmd_link.handle, 1000 / portTICK_RATE_MS), I2CTransferException); + + return process_result(); +} + +template +std::future I2CMaster::transfer(std::shared_ptr xfer, uint8_t i2c_addr) +{ + if (!xfer) throw I2CException(ESP_ERR_INVALID_ARG); + + return std::async(std::launch::async, [this](std::shared_ptr xfer, uint8_t i2c_addr) { + return xfer->do_transfer(i2c_num, i2c_addr); + }, xfer, i2c_addr); +} + +} // idf + diff --git a/examples/cxx/experimental/experimental_cpp_component/test/test_cxx_exceptions.cpp b/examples/cxx/experimental/experimental_cpp_component/test/test_cxx_exceptions.cpp index b43752ba89..e5b55ab857 100644 --- a/examples/cxx/experimental/experimental_cpp_component/test/test_cxx_exceptions.cpp +++ b/examples/cxx/experimental/experimental_cpp_component/test/test_cxx_exceptions.cpp @@ -11,7 +11,15 @@ using namespace idf; #define TAG "CXX Exception Test" -TEST_CASE("TEST_THROW catches exception", "[cxx exception]") +#if CONFIG_IDF_TARGET_ESP32 +#define LEAKS "300" +#elif CONFIG_IDF_TARGET_ESP32S2 +#define LEAKS "800" +#else +#error "unknown target in CXX tests, can't set leaks threshold" +#endif + +TEST_CASE("TEST_THROW catches exception", "[cxx exception][leaks=" LEAKS "]") { TEST_THROW(throw ESPException(ESP_FAIL);, ESPException); } @@ -28,13 +36,13 @@ TEST_CASE("TEST_THROW asserts not catching any exception", "[cxx exception][igno TEST_THROW(printf(" ");, ESPException); // need statement with effect } -TEST_CASE("CHECK_THROW continues on ESP_OK", "[cxx exception]") +TEST_CASE("CHECK_THROW continues on ESP_OK", "[cxx exception][leaks=" LEAKS "]") { esp_err_t error = ESP_OK; CHECK_THROW(error); } -TEST_CASE("CHECK_THROW throws", "[cxx exception]") +TEST_CASE("CHECK_THROW throws", "[cxx exception][leaks=" LEAKS "]") { esp_err_t error = ESP_FAIL; TEST_THROW(CHECK_THROW(error), ESPException); diff --git a/examples/cxx/experimental/experimental_cpp_component/test/test_i2c.cpp b/examples/cxx/experimental/experimental_cpp_component/test/test_i2c.cpp new file mode 100644 index 0000000000..4ce9f14a2e --- /dev/null +++ b/examples/cxx/experimental/experimental_cpp_component/test/test_i2c.cpp @@ -0,0 +1,471 @@ +// Copyright 2020 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "unity.h" +#include "unity_cxx.hpp" +#include +#include + +#include +#include "test_utils.h" // unity_send_signal + +#include "i2c_cxx.hpp" + +#ifdef __cpp_exceptions + +using namespace std; +using namespace idf; + +#define TAG "I2C Test" +#define ADDR 0x47 + +#define MAGIC_TEST_NUMBER 47 + +#define I2C_SLAVE_NUM I2C_NUM_0 /*! &data_arg = {47u}) : + master(new I2CMaster(I2C_MASTER_NUM, I2C_MASTER_SCL_IO, I2C_MASTER_SDA_IO, 400000)), + data(data_arg) { } + + std::shared_ptr master; + vector data; +}; + +TEST_CASE("I2CMaster GPIO out of range", "[cxx i2c][leaks=300]") +{ + TEST_THROW(I2CMaster(0, 255, 255, 400000), I2CException); +} + +TEST_CASE("I2CMaster SDA and SCL equal", "[cxx i2c][leaks=300]") +{ + TEST_THROW(I2CMaster(0, 0, 0, 400000), I2CException); +} + +// TODO The I2C driver tests are disabled, so disable them here, too. Probably due to no runners. +#if !TEMPORARY_DISABLED_FOR_TARGETS(ESP32S2) + +static void i2c_slave_read_raw_byte(void) +{ + I2CSlave slave(I2C_SLAVE_NUM, I2C_SLAVE_SCL_IO, I2C_SLAVE_SDA_IO, ADDR, 512, 512); + uint8_t buffer = 0; + + unity_send_signal("slave init"); + unity_wait_for_signal("master write"); + + TEST_ASSERT_EQUAL(1, slave.read_raw(&buffer, 1, chrono::milliseconds(1000))); + + TEST_ASSERT_EQUAL(MAGIC_TEST_NUMBER, buffer); +} + +static void i2c_slave_write_raw_byte(void) +{ + I2CSlave slave(I2C_SLAVE_NUM, I2C_SLAVE_SCL_IO, I2C_SLAVE_SDA_IO, ADDR, 512, 512); + uint8_t WRITE_BUFFER = MAGIC_TEST_NUMBER; + + unity_wait_for_signal("master init"); + + TEST_ASSERT_EQUAL(1, slave.write_raw(&WRITE_BUFFER, 1, chrono::milliseconds(1000))); + + unity_send_signal("slave write"); + + // This last synchronization is necessary to prevent slave from going out of scope hence de-initializing already + // before master has read + unity_wait_for_signal("master read done"); +} + +static void i2c_slave_read_multiple_raw_bytes(void) +{ + I2CSlave slave(I2C_SLAVE_NUM, I2C_SLAVE_SCL_IO, I2C_SLAVE_SDA_IO, ADDR, 512, 512); + uint8_t buffer [8] = {}; + + unity_send_signal("slave init"); + unity_wait_for_signal("master write"); + + TEST_ASSERT_EQUAL(8, slave.read_raw(buffer, 8, chrono::milliseconds(1000))); + + for (int i = 0; i < 8; i++) { + TEST_ASSERT_EQUAL(i, buffer[i]); + } +} + +static void i2c_slave_write_multiple_raw_bytes(void) +{ + I2CSlave slave(1, I2C_SLAVE_SCL_IO, I2C_SLAVE_SDA_IO, ADDR, 512, 512); + uint8_t WRITE_BUFFER [8] = {0, 1, 2, 3, 4, 5, 6, 7}; + + unity_wait_for_signal("master init"); + + TEST_ASSERT_EQUAL(8, slave.write_raw(WRITE_BUFFER, 8, chrono::milliseconds(1000))); + + unity_send_signal("slave write"); + unity_wait_for_signal("master read done"); +} + +static void i2c_slave_composed_trans(void) +{ + I2CSlave slave(1, I2C_SLAVE_SCL_IO, I2C_SLAVE_SDA_IO, ADDR, 512, 512); + size_t BUF_SIZE = 2; + const uint8_t SLAVE_WRITE_BUFFER [BUF_SIZE] = {0xde, 0xad}; + uint8_t slave_read_buffer = 0; + + unity_send_signal("slave init"); + + TEST_ASSERT_EQUAL(BUF_SIZE, slave.write_raw(SLAVE_WRITE_BUFFER, BUF_SIZE, chrono::milliseconds(1000))); + + unity_wait_for_signal("master transfer"); + + TEST_ASSERT_EQUAL(1, slave.read_raw(&slave_read_buffer, 1, chrono::milliseconds(1000))); + + TEST_ASSERT_EQUAL(MAGIC_TEST_NUMBER, slave_read_buffer); +} + +static void i2c_I2CRead(void) +{ + // here only to install/uninstall driver + MasterFixture fix; + + unity_send_signal("master init"); + unity_wait_for_signal("slave write"); + + I2CRead reader(1); + vector data = reader.do_transfer(I2C_MASTER_NUM, ADDR); + unity_send_signal("master read done"); + + TEST_ASSERT_EQUAL(1, data.size()); + TEST_ASSERT_EQUAL(MAGIC_TEST_NUMBER, data[0]); +} + +TEST_CASE_MULTIPLE_DEVICES("I2CRead do_transfer", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_I2CRead, i2c_slave_write_raw_byte); + +static void i2c_I2CWrite(void) +{ + MasterFixture fix; + + I2CWrite writer(fix.data); + + unity_wait_for_signal("slave init"); + + writer.do_transfer(I2C_MASTER_NUM, ADDR); + + unity_send_signal("master write"); +} + +TEST_CASE_MULTIPLE_DEVICES("I2CWrite do_transfer", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_I2CWrite, i2c_slave_read_raw_byte); + +static void i2c_master_read_raw_byte(void) +{ + MasterFixture fix; + + unity_send_signal("master init"); + unity_wait_for_signal("slave write"); + + std::shared_ptr reader(new I2CRead(1)); + + future > fut = fix.master->transfer(reader, ADDR); + + vector data; + data = fut.get(); + unity_send_signal("master read done"); + + TEST_ASSERT_EQUAL(1, data.size()); + TEST_ASSERT_EQUAL(MAGIC_TEST_NUMBER, data[0]); +} + +TEST_CASE_MULTIPLE_DEVICES("I2CMaster read one byte", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_master_read_raw_byte, i2c_slave_write_raw_byte); + +static void i2c_master_write_raw_byte(void) +{ + MasterFixture fix; + + unity_wait_for_signal("slave init"); + + std::shared_ptr writer(new I2CWrite(fix.data)); + future fut = fix.master->transfer(writer, ADDR); + + fut.get(); + unity_send_signal("master write"); +} + +TEST_CASE_MULTIPLE_DEVICES("I2CMaster write one byte", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_master_write_raw_byte, i2c_slave_read_raw_byte); + +static void i2c_master_read_multiple_raw_bytes(void) +{ + MasterFixture fix; + + unity_send_signal("master init"); + unity_wait_for_signal("slave write"); + + std::shared_ptr reader(new I2CRead(8)); + + future > fut = fix.master->transfer(reader, ADDR); + + vector data = fut.get(); + unity_send_signal("master read done"); + + TEST_ASSERT_EQUAL(8, data.size()); + for (int i = 0; i < 8; i++) { + TEST_ASSERT_EQUAL(i, data[i]); + } +} + +TEST_CASE_MULTIPLE_DEVICES("I2CMaster read multiple bytes", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_master_read_multiple_raw_bytes, i2c_slave_write_multiple_raw_bytes); + +static void i2c_master_write_multiple_raw_bytes(void) +{ + MasterFixture fix({0, 1, 2, 3, 4, 5, 6, 7}); + + unity_wait_for_signal("slave init"); + + std::shared_ptr writer(new I2CWrite(fix.data)); + future fut = fix.master->transfer(writer, ADDR); + + fut.get(); + unity_send_signal("master write"); +} + +TEST_CASE_MULTIPLE_DEVICES("I2CMaster write multiple bytes", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_master_write_multiple_raw_bytes, i2c_slave_read_multiple_raw_bytes); + +static void i2c_master_sync_read(void) +{ + MasterFixture fix; + + unity_send_signal("master init"); + unity_wait_for_signal("slave write"); + + vector data = fix.master->sync_read(ADDR, 1); + + unity_send_signal("master read done"); + + TEST_ASSERT_EQUAL(1, data.size()); + TEST_ASSERT_EQUAL(MAGIC_TEST_NUMBER, data[0]); +} + +TEST_CASE_MULTIPLE_DEVICES("I2CMaster sync read", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_master_sync_read, i2c_slave_write_raw_byte); + +static void i2c_master_sync_write(void) +{ + MasterFixture fix; + + unity_wait_for_signal("slave init"); + + fix.master->sync_write(ADDR, fix.data); + + unity_send_signal("master write"); +} + +TEST_CASE_MULTIPLE_DEVICES("I2CMaster sync write", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_master_sync_write, i2c_slave_read_raw_byte); + +static void i2c_master_sync_transfer(void) +{ + MasterFixture fix; + size_t READ_SIZE = 2; + const uint8_t DESIRED_READ [READ_SIZE] = {0xde, 0xad}; + + unity_wait_for_signal("slave init"); + + vector read_data = fix.master->sync_transfer(ADDR, fix.data, READ_SIZE); + + unity_send_signal("master transfer"); + TEST_ASSERT_EQUAL(READ_SIZE, read_data.size()); + for (int i = 0; i < READ_SIZE; i++) { + TEST_ASSERT_EQUAL(DESIRED_READ[i], read_data[i]); + } +} + +TEST_CASE_MULTIPLE_DEVICES("I2CMaster sync transfer", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_master_sync_transfer, i2c_slave_composed_trans); + +static void i2c_master_composed_trans(void) +{ + MasterFixture fix; + size_t BUF_SIZE = 2; + const uint8_t SLAVE_WRITE_BUFFER [BUF_SIZE] = {0xde, 0xad}; + + std::shared_ptr composed_transfer(new I2CComposed); + composed_transfer->add_write({47u}); + composed_transfer->add_read(BUF_SIZE); + + unity_wait_for_signal("slave init"); + + future > > result = fix.master->transfer(composed_transfer, ADDR); + + unity_send_signal("master transfer"); + + vector > read_data = result.get(); + + TEST_ASSERT_EQUAL(1, read_data.size()); + TEST_ASSERT_EQUAL(2, read_data[0].size()); + for (int i = 0; i < BUF_SIZE; i++) { + TEST_ASSERT_EQUAL(SLAVE_WRITE_BUFFER[i], read_data[0][i]); + } +} + +TEST_CASE_MULTIPLE_DEVICES("I2CMaster Composed transfer", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_master_composed_trans, i2c_slave_composed_trans); + +static void i2c_slave_write_multiple_raw_bytes_twice(void) +{ + I2CSlave slave(1, I2C_SLAVE_SCL_IO, I2C_SLAVE_SDA_IO, ADDR, 512, 512); + const size_t BUF_SIZE = 8; + uint8_t WRITE_BUFFER [BUF_SIZE] = {0, 1, 2, 3, 4, 5, 6, 7}; + + unity_wait_for_signal("master init"); + + TEST_ASSERT_EQUAL(BUF_SIZE, slave.write_raw(WRITE_BUFFER, BUF_SIZE, chrono::milliseconds(1000))); + TEST_ASSERT_EQUAL(BUF_SIZE, slave.write_raw(WRITE_BUFFER, BUF_SIZE, chrono::milliseconds(1000))); + + unity_send_signal("slave write"); + unity_wait_for_signal("master read done"); +} + +static void i2c_master_reuse_read_multiple_raw_bytes(void) +{ + MasterFixture fix; + + unity_send_signal("master init"); + unity_wait_for_signal("slave write"); + const size_t BUF_SIZE = 8; + + std::shared_ptr reader(new I2CRead(BUF_SIZE)); + + future > fut; + fut = fix.master->transfer(reader, ADDR); + vector data1 = fut.get(); + + fut = fix.master->transfer(reader, ADDR); + vector data2 = fut.get(); + + unity_send_signal("master read done"); + + TEST_ASSERT_EQUAL(BUF_SIZE, data1.size()); + TEST_ASSERT_EQUAL(BUF_SIZE, data2.size()); + for (int i = 0; i < BUF_SIZE; i++) { + TEST_ASSERT_EQUAL(i, data1[i]); + TEST_ASSERT_EQUAL(i, data2[i]); + } +} + +TEST_CASE_MULTIPLE_DEVICES("I2CMaster reuse read multiple bytes", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_master_reuse_read_multiple_raw_bytes, i2c_slave_write_multiple_raw_bytes_twice); + +static void i2c_slave_read_multiple_raw_bytes_twice(void) +{ + I2CSlave slave(I2C_SLAVE_NUM, I2C_SLAVE_SCL_IO, I2C_SLAVE_SDA_IO, ADDR, 512, 512); + const size_t BUF_SIZE = 8; + uint8_t buffer1 [BUF_SIZE] = {}; + uint8_t buffer2 [BUF_SIZE] = {}; + + unity_send_signal("slave init"); + unity_wait_for_signal("master write"); + + TEST_ASSERT_EQUAL(BUF_SIZE, slave.read_raw(buffer1, BUF_SIZE, chrono::milliseconds(1000))); + TEST_ASSERT_EQUAL(BUF_SIZE, slave.read_raw(buffer2, BUF_SIZE, chrono::milliseconds(1000))); + + for (int i = 0; i < BUF_SIZE; i++) { + TEST_ASSERT_EQUAL(i, buffer1[i]); + TEST_ASSERT_EQUAL(i, buffer2[i]); + } +} + +static void i2c_master_reuse_write_multiple_raw_bytes(void) +{ + MasterFixture fix({0, 1, 2, 3, 4, 5, 6, 7}); + + unity_wait_for_signal("slave init"); + + std::shared_ptr writer(new I2CWrite(fix.data)); + future fut; + fut = fix.master->transfer(writer, ADDR); + fut.get(); + + fut = fix.master->transfer(writer, ADDR); + fut.get(); + + unity_send_signal("master write"); +} + +TEST_CASE_MULTIPLE_DEVICES("I2CMaster reuse write multiple bytes", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_master_reuse_write_multiple_raw_bytes, i2c_slave_read_multiple_raw_bytes_twice); + +static void i2c_slave_composed_trans_twice(void) +{ + I2CSlave slave(1, I2C_SLAVE_SCL_IO, I2C_SLAVE_SDA_IO, ADDR, 512, 512); + size_t BUF_SIZE = 2; + const uint8_t SLAVE_WRITE_BUFFER1 [BUF_SIZE] = {0xde, 0xad}; + const uint8_t SLAVE_WRITE_BUFFER2 [BUF_SIZE] = {0xbe, 0xef}; + uint8_t slave_read_buffer = 0; + + unity_send_signal("slave init"); + + TEST_ASSERT_EQUAL(BUF_SIZE, slave.write_raw(SLAVE_WRITE_BUFFER1, BUF_SIZE, chrono::milliseconds(1000))); + TEST_ASSERT_EQUAL(BUF_SIZE, slave.write_raw(SLAVE_WRITE_BUFFER2, BUF_SIZE, chrono::milliseconds(1000))); + + unity_wait_for_signal("master transfer"); + + TEST_ASSERT_EQUAL(1, slave.read_raw(&slave_read_buffer, 1, chrono::milliseconds(1000))); + TEST_ASSERT_EQUAL(MAGIC_TEST_NUMBER, slave_read_buffer); + TEST_ASSERT_EQUAL(1, slave.read_raw(&slave_read_buffer, 1, chrono::milliseconds(1000))); + TEST_ASSERT_EQUAL(MAGIC_TEST_NUMBER, slave_read_buffer); +} + +static void i2c_master_reuse_composed_trans(void) +{ + MasterFixture fix; + size_t BUF_SIZE = 2; + const uint8_t SLAVE_WRITE_BUFFER1 [BUF_SIZE] = {0xde, 0xad}; + const uint8_t SLAVE_WRITE_BUFFER2 [BUF_SIZE] = {0xbe, 0xef}; + + std::shared_ptr composed_transfer(new I2CComposed); + composed_transfer->add_write({47u}); + composed_transfer->add_read(BUF_SIZE); + + unity_wait_for_signal("slave init"); + + vector > read_data1 = fix.master->transfer(composed_transfer, ADDR).get(); + + vector > read_data2 = fix.master->transfer(composed_transfer, ADDR).get(); + + unity_send_signal("master transfer"); + + TEST_ASSERT_EQUAL(1, read_data1.size()); + TEST_ASSERT_EQUAL(2, read_data1[0].size()); + TEST_ASSERT_EQUAL(1, read_data2.size()); + TEST_ASSERT_EQUAL(2, read_data2[0].size()); + + for (int i = 0; i < BUF_SIZE; i++) { + TEST_ASSERT_EQUAL(SLAVE_WRITE_BUFFER1[i], read_data1[0][i]); + TEST_ASSERT_EQUAL(SLAVE_WRITE_BUFFER2[i], read_data2[0][i]); + } +} + +TEST_CASE_MULTIPLE_DEVICES("I2CMaster reuse composed transfer", "[cxx i2c][test_env=UT_T2_I2C][timeout=150]", + i2c_master_reuse_composed_trans, i2c_slave_composed_trans_twice); +#endif //TEMPORARY_DISABLED_FOR_TARGETS(ESP32S2) + +#endif // __cpp_exceptions diff --git a/examples/cxx/experimental/sensor_mcp9808/CMakeLists.txt b/examples/cxx/experimental/sensor_mcp9808/CMakeLists.txt new file mode 100644 index 0000000000..e6571f0e98 --- /dev/null +++ b/examples/cxx/experimental/sensor_mcp9808/CMakeLists.txt @@ -0,0 +1,8 @@ +# The following lines of boilerplate have to be in your project's CMakeLists +# in this exact order for cmake to work correctly +cmake_minimum_required(VERSION 3.5) + +set(EXTRA_COMPONENT_DIRS "$ENV{IDF_PATH}/examples/cxx/experimental/experimental_cpp_component") + +include($ENV{IDF_PATH}/tools/cmake/project.cmake) +project(sensor_mcp9808) diff --git a/examples/cxx/experimental/sensor_mcp9808/Makefile b/examples/cxx/experimental/sensor_mcp9808/Makefile new file mode 100644 index 0000000000..507667bb67 --- /dev/null +++ b/examples/cxx/experimental/sensor_mcp9808/Makefile @@ -0,0 +1,11 @@ +# +# This is a project Makefile. It is assumed the directory this Makefile resides in is a +# project subdirectory. +# + +EXTRA_COMPONENT_DIRS += ${IDF_PATH}/examples/cxx/experimental/experimental_cpp_component + +PROJECT_NAME := sensor_mcp9808 + +include $(IDF_PATH)/make/project.mk + diff --git a/examples/cxx/experimental/sensor_mcp9808/README.md b/examples/cxx/experimental/sensor_mcp9808/README.md new file mode 100644 index 0000000000..b980bec467 --- /dev/null +++ b/examples/cxx/experimental/sensor_mcp9808/README.md @@ -0,0 +1,49 @@ +# Example: C++ I2C sensor read for MCP9808 + +(See the README.md file in the upper level 'examples' directory for more information about examples.) + +This example demonstrates usage of C++ exceptions in ESP-IDF. + +In this example, the `sdkconfig.defaults` file sets the `CONFIG_COMPILER_CXX_EXCEPTIONS` option. +This enables both compile time support (`-fexceptions` compiler flag) and run-time support for C++ exception handling. +This is necessary for the C++ I2C API. + +## How to use example + +### Hardware Required + +An MCP9808 sensor and any commonly available ESP32 development board. +Pullups aren't necessary as the default pullups are enabled in the I2CMaster class. + +### Configure the project + +``` +idf.py menuconfig +``` + +### Build and Flash + +``` +idf.py -p PORT flash monitor +``` + +(Replace PORT with the name of the serial port.) + +(To exit the serial monitor, type ``Ctrl-]``.) + +See the Getting Started Guide for full steps to configure and use ESP-IDF to build projects. + +## Example Output + +If the sensor is read correctly: + +``` +Current temperature: 24.875 +``` + +If something went wrong: +``` +I2C Exception with error: -1 +Coulnd't read sensor! +``` + diff --git a/examples/cxx/experimental/sensor_mcp9808/main/CMakeLists.txt b/examples/cxx/experimental/sensor_mcp9808/main/CMakeLists.txt new file mode 100644 index 0000000000..dfbb7db4c1 --- /dev/null +++ b/examples/cxx/experimental/sensor_mcp9808/main/CMakeLists.txt @@ -0,0 +1,2 @@ +idf_component_register(SRCS "sensor_mcp9808.cpp" + INCLUDE_DIRS ".") diff --git a/examples/cxx/experimental/sensor_mcp9808/main/component.mk b/examples/cxx/experimental/sensor_mcp9808/main/component.mk new file mode 100644 index 0000000000..a98f634eae --- /dev/null +++ b/examples/cxx/experimental/sensor_mcp9808/main/component.mk @@ -0,0 +1,4 @@ +# +# "main" pseudo-component makefile. +# +# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.) diff --git a/examples/cxx/experimental/sensor_mcp9808/main/sensor_mcp9808.cpp b/examples/cxx/experimental/sensor_mcp9808/main/sensor_mcp9808.cpp new file mode 100644 index 0000000000..cd3dc59f9b --- /dev/null +++ b/examples/cxx/experimental/sensor_mcp9808/main/sensor_mcp9808.cpp @@ -0,0 +1,44 @@ +#include +#include "i2c_cxx.hpp" + +using namespace std; +using namespace idf; + +#define ADDR 0x18 +#define I2C_MASTER_NUM I2C_NUM_0 /*!< I2C port number for master dev */ +#define I2C_MASTER_SCL_IO 19 /*!< gpio number for I2C master clock */ +#define I2C_MASTER_SDA_IO 18 /*!< gpio number for I2C master data */ + +#define MCP_9808_TEMP_REG 0x05 + +/** + * Calculates the temperature of the MCP9808 from the read msb and lsb. Loosely adapted from the MCP9808's datasheet. + */ +float calc_temp(uint8_t msb, uint8_t lsb) { + float temperature; + msb &= 0x1F; + bool sign = msb & 0x10; + if (sign) { + msb &= 0x0F; + temperature = 256 - (msb * 16 + (float) lsb / 16); + } else { + temperature = (msb * 16 + (float) lsb / 16); + } + + return temperature; +} + +extern "C" void app_main(void) +{ + try { + // creating master bus, writing temperature register pointer and reading the value + shared_ptr master(new I2CMaster(I2C_MASTER_NUM, I2C_MASTER_SCL_IO, I2C_MASTER_SDA_IO, 400000)); + master->sync_write(ADDR, {MCP_9808_TEMP_REG}); + vector data = master->sync_read(ADDR, 2); + + cout << "Current temperature: " << calc_temp(data[0], data[1]) << endl; + } catch (const I2CException &e) { + cout << "I2C Exception with error: " << e.error << endl; + cout << "Coulnd't read sensor!" << endl; + } +} diff --git a/examples/cxx/experimental/sensor_mcp9808/sdkconfig.defaults b/examples/cxx/experimental/sensor_mcp9808/sdkconfig.defaults new file mode 100644 index 0000000000..a365ac6589 --- /dev/null +++ b/examples/cxx/experimental/sensor_mcp9808/sdkconfig.defaults @@ -0,0 +1,3 @@ +# Enable C++ exceptions and set emergency pool size for exception objects +CONFIG_COMPILER_CXX_EXCEPTIONS=y +CONFIG_COMPILER_CXX_EXCEPTIONS_EMG_POOL_SIZE=1024 diff --git a/tools/ci/config/build.yml b/tools/ci/config/build.yml index 7c00d383da..6938628d52 100644 --- a/tools/ci/config/build.yml +++ b/tools/ci/config/build.yml @@ -159,6 +159,7 @@ build_examples_make: build_examples_cmake_esp32: extends: .build_examples_cmake + parallel: 10 variables: IDF_TARGET: esp32 diff --git a/tools/unit-test-app/components/test_utils/include/test_utils.h b/tools/unit-test-app/components/test_utils/include/test_utils.h index d6037079c6..f69b18fe45 100644 --- a/tools/unit-test-app/components/test_utils/include/test_utils.h +++ b/tools/unit-test-app/components/test_utils/include/test_utils.h @@ -24,6 +24,10 @@ /* include performance pass standards header file */ #include "idf_performance.h" +#ifdef __cplusplus +extern "C" { +#endif + /* For performance check with unity test on IDF */ /* These macros should only be used with ESP-IDF. * To use performance check, we need to first define pass standard in idf_performance.h. @@ -36,12 +40,12 @@ #define _PERFORMANCE_CON(a, b) a##b #define TEST_PERFORMANCE_LESS_THAN(name, value_fmt, value) do { \ - printf("[Performance]["PERFORMANCE_STR(name)"]: "value_fmt"\n", value); \ + printf("[Performance][" PERFORMANCE_STR(name) "]: "value_fmt"\n", value); \ TEST_ASSERT(value < PERFORMANCE_CON(IDF_PERFORMANCE_MAX_, name)); \ } while(0) #define TEST_PERFORMANCE_GREATER_THAN(name, value_fmt, value) do { \ - printf("[Performance]["PERFORMANCE_STR(name)"]: "value_fmt"\n", value); \ + printf("[Performance][" PERFORMANCE_STR(name) "]: "value_fmt"\n", value); \ TEST_ASSERT(value > PERFORMANCE_CON(IDF_PERFORMANCE_MIN_, name)); \ } while(0) @@ -277,3 +281,7 @@ void test_utils_free_exhausted_memory(test_utils_exhaust_memory_rec rec); * @param[in] thandle Handle of task to be deleted (should not be NULL or self handle) */ void test_utils_task_delete(TaskHandle_t thandle); + +#ifdef __cplusplus +} +#endif diff --git a/tools/unit-test-app/configs/cxx_experimental b/tools/unit-test-app/configs/cxx_experimental new file mode 100644 index 0000000000..88d1fef3c3 --- /dev/null +++ b/tools/unit-test-app/configs/cxx_experimental @@ -0,0 +1,2 @@ +TEST_COMPONENTS=experimental_cpp_component +CONFIG_COMPILER_CXX_EXCEPTIONS=y diff --git a/tools/unit-test-app/configs/default_2 b/tools/unit-test-app/configs/default_2 index 83423506bd..416badb565 100644 --- a/tools/unit-test-app/configs/default_2 +++ b/tools/unit-test-app/configs/default_2 @@ -1,3 +1,3 @@ # This config is split between targets since different component needs to be excluded (esp32, esp32s2) CONFIG_IDF_TARGET="esp32" -TEST_EXCLUDE_COMPONENTS=libsodium bt app_update freertos esp32 esp_ipc esp_timer driver heap pthread soc spi_flash vfs test_utils +TEST_EXCLUDE_COMPONENTS=libsodium bt app_update freertos esp32 esp_ipc esp_timer driver heap pthread soc spi_flash vfs test_utils experimental_cpp_component diff --git a/tools/unit-test-app/configs/default_2_s2 b/tools/unit-test-app/configs/default_2_s2 index 0783940176..a99b0e083f 100644 --- a/tools/unit-test-app/configs/default_2_s2 +++ b/tools/unit-test-app/configs/default_2_s2 @@ -1,3 +1,3 @@ # This config is split between targets since different component needs to be excluded (esp32, esp32s2) CONFIG_IDF_TARGET="esp32s2" -TEST_EXCLUDE_COMPONENTS=libsodium bt app_update freertos esp32s2 esp_ipc esp_timer driver heap pthread soc spi_flash vfs +TEST_EXCLUDE_COMPONENTS=libsodium bt app_update freertos esp32s2 esp_ipc esp_timer driver heap pthread soc spi_flash vfs experimental_cpp_component diff --git a/tools/unit-test-app/configs/psram b/tools/unit-test-app/configs/psram index 86efe9afab..d7b5876d99 100644 --- a/tools/unit-test-app/configs/psram +++ b/tools/unit-test-app/configs/psram @@ -1,5 +1,5 @@ CONFIG_IDF_TARGET="esp32" -TEST_EXCLUDE_COMPONENTS=libsodium bt app_update driver esp32 esp_ipc esp_timer mbedtls spi_flash test_utils heap pthread soc +TEST_EXCLUDE_COMPONENTS=libsodium bt app_update driver esp32 esp_ipc esp_timer mbedtls spi_flash test_utils heap pthread soc experimental_cpp_component CONFIG_ESP32_SPIRAM_SUPPORT=y CONFIG_ESP_INT_WDT_TIMEOUT_MS=800 CONFIG_SPIRAM_OCCUPY_NO_HOST=y diff --git a/tools/unit-test-app/configs/release_2 b/tools/unit-test-app/configs/release_2 index 9d116fd570..a2d90b290b 100644 --- a/tools/unit-test-app/configs/release_2 +++ b/tools/unit-test-app/configs/release_2 @@ -1,6 +1,6 @@ # This config is split between targets since different component needs to be included (esp32, esp32s2) CONFIG_IDF_TARGET="esp32" -TEST_EXCLUDE_COMPONENTS=libsodium bt app_update freertos esp32 esp_ipc esp_timer driver heap pthread soc spi_flash vfs test_utils +TEST_EXCLUDE_COMPONENTS=libsodium bt app_update freertos esp32 esp_ipc esp_timer driver heap pthread soc spi_flash vfs test_utils experimental_cpp_component CONFIG_COMPILER_OPTIMIZATION_SIZE=y CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT=y diff --git a/tools/unit-test-app/configs/release_2_s2 b/tools/unit-test-app/configs/release_2_s2 index 6ab1b2375e..ae624b14ba 100644 --- a/tools/unit-test-app/configs/release_2_s2 +++ b/tools/unit-test-app/configs/release_2_s2 @@ -1,6 +1,6 @@ # This config is split between targets since different component needs to be excluded (esp32, esp32s2) CONFIG_IDF_TARGET="esp32s2" -TEST_EXCLUDE_COMPONENTS=libsodium bt app_update freertos esp32s2 esp_ipc esp_timer driver heap pthread soc spi_flash vfs test_utils +TEST_EXCLUDE_COMPONENTS=libsodium bt app_update freertos esp32s2 esp_ipc esp_timer driver heap pthread soc spi_flash vfs test_utils experimental_cpp_component CONFIG_COMPILER_OPTIMIZATION_SIZE=y CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT=y diff --git a/tools/unit-test-app/configs/single_core_2 b/tools/unit-test-app/configs/single_core_2 index 366fb0d4cc..a1a173e4da 100644 --- a/tools/unit-test-app/configs/single_core_2 +++ b/tools/unit-test-app/configs/single_core_2 @@ -1,6 +1,6 @@ # This config is split between targets since different component needs to be excluded (esp32, esp32s2) CONFIG_IDF_TARGET="esp32" -TEST_EXCLUDE_COMPONENTS=libsodium bt app_update freertos esp32 esp_ipc esp_timer driver heap pthread soc spi_flash vfs test_utils +TEST_EXCLUDE_COMPONENTS=libsodium bt app_update freertos esp32 esp_ipc esp_timer driver heap pthread soc spi_flash vfs test_utils experimental_cpp_component CONFIG_MEMMAP_SMP=n CONFIG_FREERTOS_UNICORE=y CONFIG_ESP32_RTCDATA_IN_FAST_MEM=y diff --git a/tools/unit-test-app/configs/single_core_2_s2 b/tools/unit-test-app/configs/single_core_2_s2 index e423a94667..9cf2ed8ed4 100644 --- a/tools/unit-test-app/configs/single_core_2_s2 +++ b/tools/unit-test-app/configs/single_core_2_s2 @@ -1,6 +1,6 @@ # This config is split between targets since different component needs to be excluded (esp32, esp32s2) CONFIG_IDF_TARGET="esp32s2" -TEST_EXCLUDE_COMPONENTS=libsodium bt app_update freertos esp32s2 esp_ipc esp_timer driver heap pthread soc spi_flash vfs +TEST_EXCLUDE_COMPONENTS=libsodium bt app_update freertos esp32s2 esp_ipc esp_timer driver heap pthread soc spi_flash vfs experimental_cpp_component CONFIG_MEMMAP_SMP=n CONFIG_FREERTOS_UNICORE=y CONFIG_ESP32S2_RTCDATA_IN_FAST_MEM=y