#include <connector_uart_dma.h>

Inheritance diagram for UartDmaTsChannel:

[legend]

Collaboration diagram for UartDmaTsChannel:

[legend]

Public Member Functions
	UartDmaTsChannel (UARTDriver &uartDriver)

void	start (uint32_t baud) override

size_t	readTimeout (uint8_t *buffer, size_t size, int timeout) override

void	copyDataFromDMA ()

Public Member Functions inherited from UartTsChannel
	UartTsChannel (UARTDriver &driver)

void	start (uint32_t baud) override

void	stop () override

void	write (const uint8_t *buffer, size_t size, bool isEndOfPacket) override

size_t	readTimeout (uint8_t *buffer, size_t size, int timeout) override

Public Member Functions inherited from SerialTsChannelBase
	SerialTsChannelBase (const char *p_name)

Public Member Functions inherited from TsChannelBase
	TsChannelBase (const char *name)

virtual void	flush ()

virtual bool	isConfigured () const

virtual bool	isReady () const

size_t	read (uint8_t *buffer, size_t size)

virtual void	writeCrcPacket (uint8_t responseCode, const uint8_t *buf, size_t size, bool allowLongPackets=false)

void	sendResponse (ts_response_format_e mode, const uint8_t *buffer, int size, bool allowLongPackets=false)

void	assertPacketSize (size_t size, bool allowLongPackets)

uint32_t	writePacketHeader (const uint8_t responseCode, const size_t size)

void	crcAndWriteBuffer (const uint8_t responseCode, const size_t size)

void	copyAndWriteSmallCrcPacket (uint8_t responseCode, const uint8_t *buf, size_t size)

void	writeCrcResponse (uint8_t responseCode)

Private Attributes
uint8_t	dmaBuffer [TS_DMA_BUFFER_SIZE]

volatile int	readPos

uint8_t	buffer [TS_FIFO_BUFFER_SIZE]

input_queue_t	fifoRxQueue

Additional Inherited Members
Data Fields inherited from TsChannelBase
int	bytesIn = 0

int	bytesOut = 0

char	scratchBuffer [scratchBuffer_SIZE+30]

page1_s	page1

const char *	name

bool	in_sync = false

Protected Attributes inherited from UartTsChannel
UARTDriver *const	m_driver

UARTConfig	m_config

Detailed Description

Definition at line 19 of file connector_uart_dma.h.

Constructor & Destructor Documentation

◆ UartDmaTsChannel()

UartDmaTsChannel::UartDmaTsChannel ( UARTDriver & uartDriver )

Definition at line 45 of file connector_uart_dma.cpp.

    : UartTsChannel(driver)
{
    // Store a pointer to this instance so we can get it back later in the DMA callback
    driver.dmaAdapterInstance = this;
 
    iqObjectInit(&fifoRxQueue, buffer, sizeof(buffer), nullptr, nullptr);
}

Member Function Documentation

◆ copyDataFromDMA()

void UartDmaTsChannel::copyDataFromDMA ( )

Definition at line 13 of file connector_uart_dma.cpp.

                                       {
    chSysLockFromISR();
    // get 0-based DMA buffer position
    int dmaPos = TS_DMA_BUFFER_SIZE - dmaStreamGetTransactionSize(m_driver->dmarx);
    // if the position is wrapped (circular DMA-mode enabled)
    if (dmaPos < readPos)
        dmaPos += TS_DMA_BUFFER_SIZE;
    // we need to update the current readPos
    int newReadPos = readPos;
    for (int i = newReadPos; i < dmaPos; ) {
        if (iqPutI(&fifoRxQueue, dmaBuffer[newReadPos]) != Q_OK) {
            break; // todo: ignore overflow?
        }
        // the read position should always stay inside the buffer range
        newReadPos = (++i) & (TS_DMA_BUFFER_SIZE - 1);
    }
    readPos = newReadPos;
    chSysUnlockFromISR();
}

◆ readTimeout()

size_t UartDmaTsChannel::readTimeout	(	uint8_t *	buffer,
		size_t	size,
		int	timeout
	)

overridevirtual

Implements TsChannelBase.

Definition at line 76 of file connector_uart_dma.cpp.

                                                                                {
    // Instead of reading from the device, read from our custom RX queue
    size_t transferred = iqReadTimeout(&fifoRxQueue, p_buffer, size, timeout);
    bytesIn += transferred;
    return transferred;
}

◆ start()

void UartDmaTsChannel::start ( uint32_t baud )

overridevirtual

Implements SerialTsChannelBase.

Definition at line 54 of file connector_uart_dma.cpp.

                                          {
    m_config = {
        .txend1_cb      = NULL,
        .txend2_cb      = NULL,
        .rxend_cb       = NULL,
        .rxchar_cb      = NULL,
        .rxerr_cb       = NULL,
        .timeout_cb     = tsRxIRQIdleHandler,
        .speed          = baud,
        .cr1            = 0,
        .cr2            = USART_CR2_STOP1_BITS | USART_CR2_LINEN,
        .cr3            = 0,
        .rxhalf_cb      = tsRxIRQHalfHandler
    };
 
    uartStart(m_driver, &m_config);
 
    // Start the buffered read process
    readPos = 0;
    uartStartReceive(m_driver, sizeof(dmaBuffer), dmaBuffer);
}