DrvUart.cpp

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

#include "DrvUart.hpp"

DrvUart* DrvUart::sInstances[3];

DrvUart::DrvUart(size_t rxBufferSize, size_t txBufferSize) :
        mBufferRx(rxBufferSize), mBufferTx(txBufferSize) {
    mIntCallbacks = 0;
}

DrvUart::~DrvUart() {

}

void DrvUart::init(DrvTypes::UART port, int baudrate, DrvTypes::UART_PARITY parity, DrvTypes::UART_STOP_BITS stopBits) {
    IRQn_Type irqType;

    switch (port) {
        case DrvTypes::DRV_UART1:
            mUart = USART1;
            irqType = USART1_IRQn;
            break;
        case DrvTypes::DRV_UART2:
            mUart = USART2;
            irqType = USART2_IRQn;
            break;
        case DrvTypes::DRV_UART3:
            mUart = USART3;
            irqType = USART3_IRQn;
            break;
        default:
            return;
    }

    sInstances[port - 1] = this;

    mUart->CR1 = USART_CR1_TE | USART_CR1_RXNEIE; //0x2C;
    mUart->CR2 = 0x00;
    mUart->CR3 = 0x00;
    setBaudrate(baudrate);
    setParity(parity);
    setStopBits(stopBits);

    NVIC ->IP[irqType] = RTOS_INT_PRI;
    NVIC_EnableIRQ(irqType);
    mUart->CR1 |= USART_CR1_UE;
}

void DrvUart::setBaudrate(int baudrate) {
    uint16_t enableMask = mUart->CR1 & USART_CR1_UE;
    mUart->CR1 &= ~enableMask; //Disable
    if (mUart == USART1 ) {
        mUart->BRR = DRV_CFG_PCLK2_FREQ / baudrate;
    }
    else {
        mUart->BRR = DRV_CFG_PCLK1_FREQ / baudrate;
    }
    mBaudrate = baudrate;
    mUart->CR1 |= enableMask; //Restore previous enable state
}

void DrvUart::setParity(DrvTypes::UART_PARITY parity) {
    uint16_t enableMask = mUart->CR1 & USART_CR1_UE;
    mUart->CR1 &= ~enableMask; //Disable
    switch (parity) {
        case DrvTypes::DRV_UART_PARITY_NONE:
            mUart->CR1 &= ~(USART_CR1_PCE | USART_CR1_M );
            break;
        case DrvTypes::DRV_UART_PARITY_EVEN:
            mUart->CR1 |= USART_CR1_PCE | USART_CR1_M;
            mUart->CR1 &= ~USART_CR1_PS;
            break;
        case DrvTypes::DRV_UART_PARITY_ODD:
            mUart->CR1 |= USART_CR1_PCE | USART_CR1_M;
            mUart->CR1 |= USART_CR1_PS;
            break;
    }
    mUart->CR1 |= enableMask; //Restore previous enabled state
}

void DrvUart::setStopBits(DrvTypes::UART_STOP_BITS stopBits) {
    uint16_t enableMask = mUart->CR1 & USART_CR1_UE;
    mUart->CR1 &= ~enableMask; //Disable
    mUart->CR2 &= ~USART_CR2_STOP;
    switch (stopBits) {
        case DrvTypes::DRV_UART_STOP_BITS_1:
            break;
        case DrvTypes::DRV_UART_STOP_BITS_1_5:
            mUart->CR2 |= USART_CR2_STOP_1 | USART_CR2_STOP_0;
            break;
        case DrvTypes::DRV_UART_STOP_BITS_2:
            mUart->CR2 |= USART_CR2_STOP_1;
            break;
    }
    mUart->CR1 |= enableMask; //Restore previous enable state
}

int DrvUart::read(void* buffer, int len, Rtos::TICK timeout) {
    int left = len;
    uint8_t* p = (uint8_t*) buffer;
    while (left > 0) {
        int count = mBufferRx.read(p, left, timeout);
        if (p) {
            p += count;
        }
        if (!count) {
            break;
        }
        left -= count;
    }
    return len - left;
}

int DrvUart::write(const void* buffer, int len, Rtos::TICK timeout) {
    len = mBufferTx.write((const uint8_t*) buffer, len, timeout);
    enableTxCompletedInterrupt();
    return len;
}

void DrvUart::onInterrupt() {
    if (mIntCallbacks) {
        while (mUart->ISR & USART_ISR_RXNE) { //RX
            if (mUart->ISR & USART_ISR_PE) { //Parity error?
                mIntCallbacks->onRxParityErrorInt(mUart->RDR & 0xFF);
            }
            else {
                mIntCallbacks->onRxInt(mUart->RDR & 0xFF);
            }
        }
        if (((mUart->ISR & USART_ISR_TC) && (mUart->CR1 & USART_CR1_TCIE ))) { //TX complete
            uint8_t byte;
            if (mIntCallbacks->onTxCompletedInt(&byte)) {
                mUart->TDR = byte;
            }
            else {
                disableTxCompletedInterrupt();
            }
        }
    }
    else {
        { //RX
            int i = 0;
            uint8_t buffer[16];
            while (((mUart->ISR & USART_ISR_RXNE) && (i < (int) sizeof(buffer)))) {
                buffer[i++] = mUart->RDR & 0xFF;
            }
            mBufferRx.writeFromInt(buffer, i);
        }
        if (((mUart->ISR & USART_ISR_TC) && (mUart->CR1 & USART_CR1_TCIE ))) { //TX complete
            uint8_t buffer;
            int len = mBufferTx.readFromInt(&buffer, 1);
            if (len > 0) {
                mUart->TDR = buffer;
            }
            if (mBufferTx.getCount() == 0) {
                disableTxCompletedInterrupt();
            }
        }
    }
    if (mUart->ISR & USART_ISR_PE) { //Clear parity error flag
        mUart->ICR = USART_ICR_PECF;
    }
    if (mUart->ISR & USART_ISR_ORE) {
        mUart->ICR = USART_ICR_ORECF;
    }
}

extern "C" void RtosInterrupt::IRQ_USART1() {
    DrvUart::sInstances[0]->onInterrupt();
}

extern "C" void RtosInterrupt::IRQ_USART2() {
    DrvUart::sInstances[1]->onInterrupt();
}

extern "C" void RtosInterrupt::IRQ_USART3() {
    DrvUart::sInstances[2]->onInterrupt();
}