I2CDriver.h

Go to the documentation of this file.

/* Copyright (c) 2022 Skyward Experimental Rocketry
 * Author: Emilio Corigliano
 *
 * 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.
 */
 
#include <diagnostic/PrintLogger.h>
 
#include "miosix.h"
 
#if defined(I2C4)
#define N_I2C_PORTS 4
#elif defined(I2C3)
#define N_I2C_PORTS 3
#elif defined(I2C2)
#define N_I2C_PORTS 2
#elif defined(I2C1)
#define N_I2C_PORTS 1
#else
#error "Your architecture doesn't support I2C"
#endif
 
namespace Boardcore
{
 
class I2CDriver
{
public:
    enum Operation : uint8_t
    {
        WRITE = 0,
        READ  = 1
    };
 
    enum Speed : uint8_t
    {
        STANDARD = 0,
        FAST     = 1,
#ifdef _ARCH_CORTEXM7_STM32F7
        FAST_PLUS = 2,
        MAX_SPEED = FAST_PLUS
#else
        MAX_SPEED = FAST
#endif  // _ARCH_CORTEXM7_STM32F7
    };
 
    enum Addressing : uint8_t
    {
        BIT7  = 0,
        BIT10 = 1
    };
 
    enum Errors : uint16_t
    {
        NO_ERROR    = 0,       
        BUS_LOCKED  = 1 << 0,  
        BERR        = 1 << 1,  
        ARLO        = 1 << 2,  
        AF          = 1 << 3,  
        OVR         = 1 << 4,  
        SB_NOT_SENT = 1 << 5,  
        ADDR_ERROR  = 1 << 6   
    };
 
    typedef struct
    {
        uint16_t slaveAddress;
 
        I2CDriver::Addressing addressing = I2CDriver::Addressing::BIT7;
 
        I2CDriver::Speed speed = I2CDriver::Speed::MAX_SPEED;
 
        bool MSBFirst = false;
    } I2CSlaveConfig;
 
    I2CDriver(I2C_TypeDef* i2c, miosix::GpioPin scl, miosix::GpioPin sda);
 
    I2CDriver(const I2CDriver&)            = delete;
    I2CDriver& operator=(const I2CDriver&) = delete;
    I2CDriver(I2CDriver&&)                 = delete;
    I2CDriver& operator=(I2CDriver&&)      = delete;
 
    ~I2CDriver();
 
    [[nodiscard]] bool read(const I2CSlaveConfig& slaveConfig, void* buffer,
                            const size_t& nBytes);
 
    [[nodiscard]] bool write(const I2CSlaveConfig& slaveConfig,
                             const void* buffer, const size_t& nBytes,
                             bool generateStop = true);
 
    void flushBus();
 
    uint16_t getLastError();
 
    void IRQhandleInterrupt();
 
    void IRQhandleErrInterrupt();
 
private:
    typedef struct
    {
        Operation operation;       
        uint8_t* buffRead;         
        const uint8_t* buffWrite;  
        size_t nBytes;             
        size_t nBytesDone;         
        bool generateStop;         
    } I2CTransaction;
 
    void init();
 
    void setupPeripheral(const I2CSlaveConfig& slaveConfig);
 
#ifdef _ARCH_CORTEXM7_STM32F7
    inline void setupTransaction();
 
    inline void setupReload();
#endif  // _ARCH_CORTEXM7_STM32F7
 
    [[nodiscard]] bool doOperation(const I2CSlaveConfig& slaveConfig);
 
    inline bool IRQwaitForOperationCompletion(
        miosix::FastInterruptDisableLock& dLock);
 
    inline void IRQwakeUpWaitingThread();
 
    I2C_TypeDef* i2c;
    uint8_t id;
    IRQn_Type irqnEv;
    IRQn_Type irqnErr;
    miosix::GpioPin scl;  
    miosix::GpioPin sda;  
 
    uint16_t lastError = NO_ERROR;  
    uint32_t error     = 0;         
    bool reStarting = false;    
    miosix::Thread* waiting{};  
    I2CTransaction transaction;  
 
    PrintLogger logger = Logging::getLogger("i2c");
};
 
}  // namespace Boardcore