HardwareI2C.h

Go to the documentation of this file.

 
#ifndef HARDWAREI2C_h
#define HARDWAREI2C_h
 
//Includes
 
#if defined(STM32F103xB)
//#include "stm32f1xx_hal.h"
 
#define IS_I2C_INSTANCE_ON_APB1(_instance_) ((_instance_) == I2C2)
#define IS_I2C_INSTANCE_ON_APB2(_instance_) ((_instance_) == I2C1)
 
#elif defined(STM32F031x6) || defined(STM32F070xB) || defined(STM32F070x6) || defined(STM32F030x6)
//#include "stm32f0xx_hal.h"
 
//#define IS_I2C_INSTANCE_ON_APB2(_instance_)
#define IS_I2C_INSTANCE_ON_APB1(_instance_) ((_instance_) ==  I2C1)
 
#elif defined(STM32L031xx)
//#include "stm32l0xx_hal.h"
 
//#define IS_I2C_INSTANCE_ON_APB1(_instance_)
#define IS_I2C_INSTANCE_ON_APB2(_instance_) ((_instance_) ==  I2C1)
 
#elif defined(STM32L432xx)
//#include "stm32l4xx_hal.h"
 
 
#define IS_I2C_INSTANCE_ON_APB1(_instance_) ((_instance_) ==  I2C3)
#define IS_I2C_INSTANCE_ON_APB2(_instance_) ((_instance_) ==  I2C1)
 
#else
#error "Definitions for your MCU are not defined."
#endif
 
#include "wirish.h"
#include "Stream.h"
 
 
#ifndef I2C_BUFFER_LENGTH
// DEPRECATED: Do not use BUFFER_LENGTH, prefer I2C_BUFFER_LENGTH
#define BUFFER_LENGTH 128
#define I2C_BUFFER_LENGTH BUFFER_LENGTH
#endif
 
 
#if defined(HAL_I2C_MODULE_ENABLED) || defined(DOXYGEN_FORCED)
 
class HardwareI2C : public Stream
{
private:
    #define MAX_NBYTE_SIZE      255U
    #define RX_BUFF_SIZE        64
    #define I2C_TIMEOUT_STOPF   (25U)          
    #define I2C_TIMEOUT_BUSY    (25U)          
    //#define I2C_FLAG_BUSY       I2C_ISR_BUSY
 
    I2C_HandleTypeDef *hi2c;
 
    uint8_t rxBuffer[RX_BUFF_SIZE];
    size_t rxBufferIndex = 0;
    size_t rxBufferLength = 0;
    uint32_t timeout= 50;
    HAL_I2C_ModeTypeDef I2CMode = HAL_I2C_MODE_NONE;
 
    uint8_t _status = 0;
    uint16_t txAddress = 0;
    bool isBusReleased = true;
    uint8_t transmitting = 0;
    bool anyByteSent= false;
 
    void (*user_onRequest)(void) = NULL;
    void (*user_onReceive)(size_t) = NULL;
    void onRequestService(void);
    void onReceiveService(uint8_t*, size_t);
 
    size_t writePriv(uint8_t data);
 
    HAL_StatusTypeDef I2C_WaitOnTXISFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout,uint32_t Tickstart);
    HAL_StatusTypeDef I2C_WaitOnSTOPFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout, uint32_t Tickstart);
 
    /* Private function to handle  start, restart or stop a transfer */
     void I2C_TransferConfig(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t Size, uint32_t Mode,uint32_t Request);
 
    /* Private functions to handle flags during polling transfer */
     HAL_StatusTypeDef I2C_WaitOnFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Flag, FlagStatus Status, uint32_t Timeout, uint32_t Tickstart);
 
     HAL_StatusTypeDef I2C_IsErrorOccurred(I2C_HandleTypeDef *hi2c, uint32_t Timeout, uint32_t Tickstart);
 
     HAL_StatusTypeDef I2C_WaitOnRXNEFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout, uint32_t Tickstart);
 
     void I2C_Flush_TXDR(I2C_HandleTypeDef *hi2c);
public:
    // Constructors ////////////////////////////////////////////////////////////////
    HardwareI2C(I2C_HandleTypeDef& hi2c_) :  hi2c(&hi2c_){}
 
 
    inline bool instanceExists(void){
        return (hi2c != NULL) && (IS_I2C_ALL_INSTANCE(hi2c->Instance));
    }
 
    inline bool isMaster(void){
        return hi2c->Mode == HAL_I2C_MODE_MASTER || hi2c->Mode == HAL_I2C_MODE_MEM;
    }
 
    inline void setTimeout(uint32_t timeout_ ){
        timeout = timeout_;
    }
 
    inline uint32_t errorCode(void){
        return hi2c->ErrorCode;
    }
 
    bool begin(uint8_t adress1,uint8_t adress2 = 0);
    bool begin();
    bool end();
 
 
    void setClock(uint32_t);
    void setClockStretchLimit(uint32_t);
    bool beginTransmission(uint16_t address, uint32_t bytesCountToSend);
    bool beginTransmission(int address, uint32_t bytesCountToSend);
    uint8_t endTransmission(void);
    uint8_t endTransmission(uint8_t);
    uint8_t requestFrom(uint8_t address, size_t size, bool sendStop);
    uint8_t status();
 
    uint8_t requestFrom(uint8_t, uint8_t);
    uint8_t requestFrom(uint8_t, uint8_t, uint8_t);
    uint8_t requestFrom(int, int);
    uint8_t requestFrom(int, int, int);
 
 
    size_t write(uint8_t)override;
    size_t write(const uint8_t *, size_t)override;
 
    int available(void)override;
    int read(void)override;
    int peek(void)override;
 
    void flush(void);
    void onReceive(void (*function)(int));
    void onReceive(void (*function)(size_t));
 
    void onRequest(void (*)(void));
 
    //using Print::write;
 
 
};
 
#endif // HAL_I2C_MODULE_ENABLED || DOXYGEN_FORCED
#endif // HARDWAREI2C_h