DrvI2cMaster.cpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------

#include "DrvI2cMaster.hpp"
#include "RtosInclude.hpp"

#if !defined (STM32F10X_LD) && !defined (STM32F10X_LD_VL)
DrvI2cMaster* DrvI2cMaster::sInstances[2];
#else
DrvI2cMaster* DrvI2cMaster::sInstances[1];
#endif

DrvI2cMaster::DrvI2cMaster() :
        mSema(1, 0) {
}

void DrvI2cMaster::init(DrvTypes::I2C port, int baudrate) {
    IRQn_Type irqTypeEv;
    IRQn_Type irqTypeEr;

    switch (port) {
    case DrvTypes::DRV_I2C1:
        sInstances[0] = this;
        mI2c = I2C1;
        irqTypeEv = I2C1_EV_IRQn;
        irqTypeEr = I2C1_ER_IRQn;
        break;
#if !defined (STM32F10X_LD) && !defined (STM32F10X_LD_VL)
    case DrvTypes::DRV_I2C2:
        sInstances[1] = this;
        mI2c = I2C2;
        irqTypeEv = I2C2_EV_IRQn;
        irqTypeEr = I2C2_ER_IRQn;
        break;
#endif
    default:
        return;
    }
    mI2c->CR1 = 0;
    mI2c->CR2 = I2C_CR2_ITBUFEN | I2C_CR2_ITEVTEN | I2C_CR2_ITERREN | (DRV_CFG_PCLK1_FREQ / 1000000);
    mI2c->CCR = DRV_CFG_PCLK1_FREQ / baudrate;

    NVIC ->IP[irqTypeEv] = RTOS_INT_PRI;
    NVIC ->IP[irqTypeEr] = RTOS_INT_PRI;
    NVIC_EnableIRQ(irqTypeEv);
    NVIC_EnableIRQ(irqTypeEr);
}

void DrvI2cMaster::setSlaveAddr(uint16_t slaveAddr) {
    mSlaveAddr = slaveAddr;
}

bool DrvI2cMaster::readWrite(const uint8_t* src, int srcLen, uint8_t* dst, int dstLen) {
    mSrc = src;
    mSrcLen = srcLen;
    mDst = dst;
    mDstLen = dstLen;
    mI2c->CR1 = I2C_CR1_PE;
    mI2c->CR1 |= I2C_CR1_START;
    if (!mSema.take(Rtos::convertMsToTick(1000))) {
        mI2c->CR1 = 0;
        return false;
    }
    mI2c->CR1 = 0;
    return mResult;
}

void DrvI2cMaster::onEvent() {
    uint16_t status = mI2c->SR1;

    if (status & I2C_SR1_SB ) {
        //Temporary set result to true
        mResult = true;
        if (mSrcLen > 0) {
            mI2c->DR = mSlaveAddr;
        }
        else if (mDstLen > 0) {
            mI2c->DR = mSlaveAddr | 0x01;
        }
        else {
            mI2c->CR1 |= I2C_CR1_STOP;
        }
    }
    else if (status & I2C_SR1_ADDR ) {
        if (mSrcLen-- > 0) {
            mI2c->DR = *mSrc++;
        }
        else if (mDstLen > 0) {
            if (mDstLen > 1) {
                mI2c->CR1 |= I2C_CR1_ACK;
            }
            else {
                mI2c->CR1 &= ~I2C_CR1_ACK;
            }
        }
        else {
            mI2c->CR1 |= I2C_CR1_STOP;
        }
        volatile uint16_t dummy = mI2c->SR2; //Used to reset the flag
        dummy++; //For warning removal
    }
    else if (status & I2C_SR1_STOPF ) {
        mSema.giveFromInt();
    }
    else if (status & I2C_SR1_RXNE ) {
        if (mDstLen > 1) {
            mI2c->CR1 |= I2C_CR1_ACK;
            mDstLen--;
        }
        else if (mDstLen > 0) {
            mI2c->CR1 &= ~I2C_CR1_ACK;
            mDstLen--;
        }
        else {
            mI2c->CR1 |= I2C_CR1_STOP;
        }
        *mDst++ = mI2c->DR;
    }
    else if (status & I2C_SR1_TXE ) {
        if (mSrcLen-- > 0) {
            mI2c->DR = *mSrc++;
        }
        else if (status & I2C_SR1_BTF ) {
            mI2c->CR1 |= I2C_CR1_STOP;
        }
    }
}

void DrvI2cMaster::onError() {

    uint16_t status = mI2c->SR1;

    mResult = false;

    if (status & I2C_SR1_BERR ) {
        mI2c->SR1 |= I2C_SR1_BERR;
        mI2c->CR1 = 0;
        mSema.giveFromInt();
    }
    else if (status & I2C_SR1_ARLO ) {
        mI2c->CR1 = 0;
        mSema.giveFromInt();
    }
    else if (status & I2C_SR1_AF ) {
        mI2c->CR1 |= I2C_CR1_STOP;
    }
    else if (status & I2C_SR1_OVR ) {
        //Should never happen
        mI2c->CR1 = 0;
        mSema.giveFromInt();
    }
    else if (status & I2C_SR1_PECERR ) {
        //Should never happen
        mI2c->CR1 = 0;
        mSema.giveFromInt();
    }
    else if (status & I2C_SR1_TIMEOUT ) {
        mI2c->CR1 |= I2C_CR1_STOP;
    }
    else if (status & I2C_SR1_SMBALERT ) {
        //Should never happen
        mI2c->CR1 = 0;
        mSema.giveFromInt();
    }
}

void RtosInterrupt::IRQ_I2C1_EV() {
    DrvI2cMaster::sInstances[0]->onEvent();
}

void RtosInterrupt::IRQ_I2C1_ER() {
    DrvI2cMaster::sInstances[0]->onError();
}

#if !defined (STM32F10X_LD) && !defined (STM32F10X_LD_VL)
void RtosInterrupt::IRQ_I2C2_EV() {
    DrvI2cMaster::sInstances[1]->onEvent();
}

void RtosInterrupt::IRQ_I2C2_ER() {
    DrvI2cMaster::sInstances[1]->onError();
}
#endif