From 3e904a2e71049b4b4b853e8445b10f9fdf793600 Mon Sep 17 00:00:00 2001 From: Attila Body Date: Sat, 14 Jun 2025 08:48:07 +0200 Subject: [PATCH] Use ring buffer for console_handler --- .gitignore | 4 ++ CMakeLists.txt | 2 + inc/f4ll/console_handler.h | 27 +++++++++++-- inc/f4ll/dma_helper.h | 6 +-- inc/f4ll/ringbuffer.h | 26 ++++++++++--- inc/f4ll/usart_core.h | 1 + src/console_handler.cpp | 77 ++++++++++++++++++++++++++++---------- src/ringbuffer.cpp | 38 +++++++++++++++---- 8 files changed, 141 insertions(+), 40 deletions(-) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..c570f57 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +CMakeFiles/ +CMakeCache.txt +build.ninja +cmake_install.cmake \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index b71828d..1236174 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,3 +1,5 @@ +cmake_minimum_required(VERSION 3.22) + add_library(f4ll STATIC src/console_handler.cpp src/crc_handler.cpp diff --git a/inc/f4ll/console_handler.h b/inc/f4ll/console_handler.h index 27a2a7e..9ab5e4a 100644 --- a/inc/f4ll/console_handler.h +++ b/inc/f4ll/console_handler.h @@ -18,12 +18,26 @@ class console_handler : public usart_core, public initialized_singleton; public: + using size_type = iringbuffer::size_type; + + class iconsole_input + { + public: + virtual void input_available(size_type len) = 0; + }; + void print(char const *s); void flush(); - size_t append(char const *s); + size_type append(char const *s); + + iringbuffer &get_rx_buffer() { return m_rx_buffer; } private: - console_handler(USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t stream_rx, uint32_t stream_tx); + console_handler( + USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t stream_rx, uint32_t stream_tx, uint8_t *rx_buffer, size_type x_buffer_size, + uint8_t *tx_buffer, size_type tx_buffer_size, iconsole_input *rx_callback); + + void setup_receive(void); // LL_UsartCore pure virtual function implementations virtual void receiver_idle(void) override; @@ -37,8 +51,13 @@ private: virtual void tx_dma_half_transfer(void) override; virtual void tx_dma_error(dma_helper::dma_error_type reason) override; - ringbuffer<128> m_tx_buffer; - iringbuffer::size_type m_in_flight_size = 0; + ringbuffer_ext m_tx_buffer; + size_type m_bytes_sent = 0; + + ringbuffer_ext m_rx_buffer; + size_type m_bytes_requested = 0; + size_type m_reqd_bytes_registered = 0; + iconsole_input *m_rx_callback; }; } /* namespace f4ll */ diff --git a/inc/f4ll/dma_helper.h b/inc/f4ll/dma_helper.h index 82347e7..0b8719e 100644 --- a/inc/f4ll/dma_helper.h +++ b/inc/f4ll/dma_helper.h @@ -38,9 +38,9 @@ public: private: DMA_TypeDef *m_dma; - uint32_t m_stream; - volatile uint32_t *m_is_reg; - volatile uint32_t *m_ifc_reg; + uint32_t const m_stream; + volatile uint32_t * const m_is_reg; + volatile uint32_t * const m_ifc_reg; static constexpr uint32_t const m_fe_masks[8] = {DMA_LISR_FEIF0, DMA_LISR_FEIF1, DMA_LISR_FEIF2, DMA_LISR_FEIF3, DMA_HISR_FEIF4, DMA_HISR_FEIF5, DMA_HISR_FEIF6, DMA_HISR_FEIF7}; diff --git a/inc/f4ll/ringbuffer.h b/inc/f4ll/ringbuffer.h index 9ba2ccc..82f1891 100644 --- a/inc/f4ll/ringbuffer.h +++ b/inc/f4ll/ringbuffer.h @@ -35,22 +35,30 @@ public: /// without registering the consumption. /// The caller should also call report_consumption using the returned /// chunk length after it finished processing the data. - /// @param[in] len_requested Length of the data requested from the buffer. - /// The length of the actual data provided - /// might be actually smaller (because either reaching the end of - /// the buffer or not enough data in the buffer). /// @param[out] data Receives a pointer to the first byte of the available /// data in the buffer /// @param[out] len Receives the length of the chunk available in the buffer. /// Will not exceed len_requested. /// @retval true if the buffer has more available data, false otherwise. - virtual bool get_chunk(size_type len_requested, uint8_t const *&data, size_type &len) const = 0; + virtual bool get_chunk(uint8_t const *&data, size_type &len) const = 0; /// @brief Marks the chunk returned by ringbuffer_GetChunk as available. /// @param consumed The length of the chunk as returned by /// ringbuffer_GetChunk(..., len) virtual void consumed(size_type len) = 0; + /// @brief Gets a pointer to the next free chunk in the buffer + /// @retval Pointer to the beginning of the next free buffer chmemory area + /// @param[out] len Receives the length of the returned buffer area. + virtual uint8_t *get_free_chunk(size_type &len) = 0; + + /// @brief Registers the data written in the free buffer chunk. + /// IMPORTANT: Do not call put() after start modifying the buffer + /// returned by get_free_chunk() before registering the written data by + /// calling supplied() + /// @param len The length of the data written in the buffer + virtual bool produced(size_type len) = 0; + /// @brief Returns the number of uncommited bytes in the ring buffer. virtual size_type uncommited() const = 0; @@ -80,8 +88,13 @@ public: size_type put(uint8_t const *data, size_type len) override; void commit() override; - bool get_chunk(size_type len_requested, uint8_t const *&data, size_type &len) const override; + + bool get_chunk(uint8_t const *&data, size_type &len) const override; void consumed(size_type len) override; + + uint8_t *get_free_chunk(size_type &len) override; + bool produced(size_type len) override; + size_type uncommited() const override; size_type commited() const override; void discard() override; @@ -98,6 +111,7 @@ private: size_type m_tail = 0; //!< Read position size_type marker_diff(size_type m1, size_type m2) const; + size_type max_chunk_len() const; }; // diff --git a/inc/f4ll/usart_core.h b/inc/f4ll/usart_core.h index 508df34..fa17f2d 100644 --- a/inc/f4ll/usart_core.h +++ b/inc/f4ll/usart_core.h @@ -31,6 +31,7 @@ protected: dma_helper m_tx_dma; private: + // these functions are called from interrup context! virtual void receiver_idle(void) = 0; virtual void transmission_complete(void) = 0; virtual void framing_error(void) = 0; diff --git a/src/console_handler.cpp b/src/console_handler.cpp index a4ba4a6..2ddd37d 100644 --- a/src/console_handler.cpp +++ b/src/console_handler.cpp @@ -5,6 +5,7 @@ * Author: abody */ +#include #include #include #include @@ -13,24 +14,36 @@ namespace f4ll { -console_handler::console_handler(USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t stream_rx, uint32_t stream_tx) - : usart_core(usart, dma, stream_rx, stream_tx) +console_handler::console_handler( + USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t stream_rx, uint32_t stream_tx, uint8_t *rx_buffer, size_type rx_buffer_size, + uint8_t *tx_buffer, size_type tx_buffer_size, iconsole_input *rx_callback) + : usart_core(usart, dma, stream_rx, stream_tx), + m_tx_buffer(tx_buffer, tx_buffer_size), + m_rx_buffer(rx_buffer, rx_buffer_size), + m_rx_callback(rx_callback) { + LL_USART_EnableIT_IDLE(usart); + LL_USART_EnableIT_ERROR(usart); + setup_receive(); } -void console_handler::receiver_idle(void) {} - -void console_handler::transmission_complete(void) +void console_handler::setup_receive(void) { - m_tx_buffer.consumed(m_in_flight_size); - if (m_tx_buffer.commited()) { - uint8_t const *chunk; - m_tx_buffer.get_chunk(m_tx_buffer.size(), chunk, m_in_flight_size); - if (m_in_flight_size) { - setup_transmit(chunk, m_in_flight_size); + uint8_t *bptr = m_rx_buffer.get_free_chunk(m_bytes_requested); + m_reqd_bytes_registered = 0; + usart_core::setup_receive(bptr, m_bytes_requested); +} + +void console_handler::receiver_idle(void) +{ + uint16_t rcvd_bytes = m_bytes_requested - m_reqd_bytes_registered - LL_DMA_GetDataLength(m_rx_dma.get_dma(), m_rx_dma.get_stream()); + if (rcvd_bytes) { + m_reqd_bytes_registered += rcvd_bytes; + m_rx_buffer.produced(rcvd_bytes); + m_rx_buffer.commit(); + if (m_rx_callback) { + m_rx_callback->input_available(rcvd_bytes); } - } else { - m_in_flight_size = 0; } } @@ -38,7 +51,19 @@ void console_handler::framing_error(void) {} void console_handler::overrun(void) {} -void console_handler::rx_dma_transfer_complete(void) {} +void console_handler::rx_dma_transfer_complete(void) +{ + LL_DMA_DisableStream(m_rx_dma.get_dma(), m_rx_dma.get_stream()); + uint16_t rcvd_bytes = m_bytes_requested - m_reqd_bytes_registered - LL_DMA_GetDataLength(m_rx_dma.get_dma(), m_rx_dma.get_stream()); + if (rcvd_bytes) { + m_rx_buffer.produced(rcvd_bytes); + setup_receive(); + m_rx_buffer.commit(); + if (m_rx_callback) { + m_rx_callback->input_available(rcvd_bytes); + } + } +} void console_handler::rx_dma_half_transfer(void) {} @@ -53,6 +78,20 @@ void console_handler::tx_dma_transfer_complete(void) LL_DMA_DisableStream(m_tx_dma.get_dma(), m_tx_dma.get_stream()); } +void console_handler::transmission_complete(void) +{ + m_tx_buffer.consumed(m_bytes_sent); + if (m_tx_buffer.commited()) { + uint8_t const *chunk; + m_tx_buffer.get_chunk(chunk, m_bytes_sent); + if (m_bytes_sent) { + setup_transmit(chunk, m_bytes_sent); + } + } else { + m_bytes_sent = 0; + } +} + void console_handler::tx_dma_half_transfer(void) {} void console_handler::tx_dma_error(dma_helper::dma_error_type reason) @@ -60,7 +99,7 @@ void console_handler::tx_dma_error(dma_helper::dma_error_type reason) (void)reason; } -size_t console_handler::append(char const *s) +console_handler::size_type console_handler::append(char const *s) { size_t len = strlen(s); if (!len) { @@ -76,14 +115,14 @@ void console_handler::flush() } m_tx_buffer.commit(); - if (m_in_flight_size) { + if (m_bytes_sent) { return; } uint8_t const *chunk; - m_tx_buffer.get_chunk(m_tx_buffer.size(), chunk, m_in_flight_size); - if (m_in_flight_size) { - setup_transmit(chunk, m_in_flight_size); + m_tx_buffer.get_chunk(chunk, m_bytes_sent); + if (m_bytes_sent) { + setup_transmit(chunk, m_bytes_sent); } } diff --git a/src/ringbuffer.cpp b/src/ringbuffer.cpp index 5354f95..c5a46e3 100644 --- a/src/ringbuffer.cpp +++ b/src/ringbuffer.cpp @@ -49,12 +49,8 @@ void ringbuffer_ext::commit() m_head = m_head_shadow; } -bool ringbuffer_ext::get_chunk(size_type len_requested, uint8_t const *&data, size_type &len) const +bool ringbuffer_ext::get_chunk(uint8_t const *&data, size_type &len) const { - if (!len_requested) { - return false; - } - size_type head = m_head; size_type tail = m_tail; size_type chunk_size = head >= tail ? head - tail : m_bsize - tail; @@ -64,9 +60,6 @@ bool ringbuffer_ext::get_chunk(size_type len_requested, uint8_t const *&data, si return tail != head; } - if (chunk_size > len_requested) { - chunk_size = len_requested; - } data = m_buffer + tail; len = chunk_size; @@ -89,6 +82,35 @@ void ringbuffer_ext::consumed(size_type len) } } +iringbuffer::size_type ringbuffer_ext::max_chunk_len() const +{ + if (m_tail <= m_head_shadow) { + return m_bsize - m_head_shadow - (m_tail ? 0 : 1); + } else { + return m_tail - m_head_shadow - 1; + } +} + +uint8_t *ringbuffer_ext::get_free_chunk(size_type &len) +{ + len = max_chunk_len(); + + return m_buffer + m_head_shadow; +} + +bool ringbuffer_ext::produced(size_type len) +{ + size_type max_len = max_chunk_len(); + if (len > max_len) { + return false; + } + m_head_shadow += len; + if (m_head_shadow == m_bsize) { + m_head_shadow = 0; + } + return true; +} + iringbuffer::size_type ringbuffer_ext::uncommited() const { return marker_diff(m_head_shadow, m_head);