diff --git a/components/f4ll/inc/f4ll/console_handler.h b/components/f4ll/inc/f4ll/console_handler.h index cb695fd..34da08c 100644 --- a/components/f4ll/inc/f4ll/console_handler.h +++ b/components/f4ll/inc/f4ll/console_handler.h @@ -24,16 +24,16 @@ private: console_handler(USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t stream_rx, uint32_t stream_tx); // LL_UsartCore pure virtual function implementations - virtual void receiver_idle(void); - virtual void transmission_complete(void); - virtual void framing_error(void); - virtual void overrun(void); - virtual void rx_dma_transfer_complete(void); - virtual void rx_dma_half_transfer(void); - virtual void rx_dma_error(dma_helper::dma_error_type reason); - virtual void tx_dma_transfer_complete(void); - virtual void tx_dma_half_transfer(void); - virtual void tx_dma_error(dma_helper::dma_error_type reason); + virtual void receiver_idle(void) override; + virtual void transmission_complete(void) override; + virtual void framing_error(void) override; + virtual void overrun(void) override; + virtual void rx_dma_transfer_complete(void) override; + virtual void rx_dma_half_transfer(void) override; + virtual void rx_dma_error(dma_helper::dma_error_type reason) override; + virtual void tx_dma_transfer_complete(void) override; + virtual void tx_dma_half_transfer(void) override; + virtual void tx_dma_error(dma_helper::dma_error_type reason) override; char m_buffer[128]; uint16_t m_used = 0; diff --git a/components/f4ll/inc/f4ll/dma_helper.h b/components/f4ll/inc/f4ll/dma_helper.h index fcf0250..534b59f 100644 --- a/components/f4ll/inc/f4ll/dma_helper.h +++ b/components/f4ll/inc/f4ll/dma_helper.h @@ -29,11 +29,11 @@ public: inline uint32_t get_ht_mask() const { return m_ht_masks[m_stream]; } inline uint32_t get_tc_mask() const { return m_tc_masks[m_stream]; } - inline bool is_enabled_it_ht() { return LL_DMA_IsEnabledIT_HT(m_dma, m_stream) != 0; } - inline bool is_enabled_it_te() { return LL_DMA_IsEnabledIT_TE(m_dma, m_stream) != 0; } - inline bool is_enabled_it_tc() { return LL_DMA_IsEnabledIT_TC(m_dma, m_stream) != 0; } - inline bool is_enabled_it_dme() { return LL_DMA_IsEnabledIT_DME(m_dma, m_stream) != 0; } - inline bool is_enabled_it_fe() { return LL_DMA_IsEnabledIT_FE(m_dma, m_stream) != 0; } + inline bool is_enabled_it_ht() const { return LL_DMA_IsEnabledIT_HT(m_dma, m_stream) != 0; } + inline bool is_enabled_it_te() const { return LL_DMA_IsEnabledIT_TE(m_dma, m_stream) != 0; } + inline bool is_enabled_it_tc() const { return LL_DMA_IsEnabledIT_TC(m_dma, m_stream) != 0; } + inline bool is_enabled_it_dme() const { return LL_DMA_IsEnabledIT_DME(m_dma, m_stream) != 0; } + inline bool is_enabled_it_fe() const { return LL_DMA_IsEnabledIT_FE(m_dma, m_stream) != 0; } enum class dma_error_type { transfer, direct_mode, fifo }; diff --git a/components/f4ll/inc/f4ll/packet_usart.h b/components/f4ll/inc/f4ll/packet_usart.h index 33dbb2d..649a813 100644 --- a/components/f4ll/inc/f4ll/packet_usart.h +++ b/components/f4ll/inc/f4ll/packet_usart.h @@ -29,21 +29,21 @@ public: uint8_t hash; }; - struct Packet + struct packet { packet_header header; uint8_t payload[256 + sizeof(uint32_t)]; // extra room for crc32 } __attribute__((aligned)); - struct Stats + struct stats { uint32_t overrun = 0; - uint32_t hdrError = 0; - uint32_t payloadErrror = 0; + uint32_t hdr_error = 0; + uint32_t payload_errror = 0; uint32_t pep1 = 0; uint32_t pep2 = 0; - uint32_t rxDmaError = 0; - uint32_t txDmaError = 0; + uint32_t rx_dma_error = 0; + uint32_t tx_dma_error = 0; uint32_t rcvd = 0; uint32_t premature_hdr = 0; uint32_t premature_payload = 0; @@ -51,71 +51,71 @@ public: uint32_t skiped = 0; }; - struct IHsUsartCallback + struct ihs_usart_callback { - virtual bool PacketReceived(packet_usart *caller, uintptr_t userParam, Packet const &packet) = 0; + virtual bool packet_received(packet_usart *caller, uintptr_t user_param, packet const &packet) = 0; }; // crc_handler::ICallback interface functions - virtual void crc_succeeded(uintptr_t callbackParam, uint32_t crc, uint8_t task); - virtual void crc_failed(uintptr_t callbackParam, uint32_t crc, uint8_t task); + virtual void crc_succeeded(uintptr_t callback_param, uint32_t crc, uint8_t task) override; + virtual void crc_failed(uintptr_t callback_param, uint32_t crc, uint8_t task) override; - void PostPacket(uint8_t const *payload, uint8_t length, bool wait_for_crc_queue = true); - void SetupReceive(void); + void post_packet(uint8_t const *payload, uint8_t length, bool wait_for_crc_queue = true); + void setup_receive(void); - void RxProcessed(bool second); + void rx_processed(bool second); // Getters - uint8_t *GetTxPacketBuffer(void) { return m_txBuffer.packet.payload; } - uint8_t const *GetRxPacketBuffer(bool second) { return m_rxBuffers[second].packet.payload; } - USART_TypeDef *GetUsart(void) const { return m_usart; } - Stats const &GetStats(void) const { return m_stats; } - inline bool IsTxBusy(void) const { return m_txBuffer.busy; } - inline bool IsTxFailed(void) const { return m_txBuffer.error; } - inline bool IsRxBusy(bool second) const { return m_rxBuffers[second].busy; } - inline bool IsRxFailed(bool second) const { return m_rxBuffers[second].error; } + uint8_t *get_tx_packet_buffer(void) { return m_tx_buffer.pkt.payload; } + uint8_t const *get_rx_packet_buffer(bool second) { return m_rx_buffers[second].pkt.payload; } + USART_TypeDef *get_usart(void) const { return m_usart; } + stats const &get_stats(void) const { return m_stats; } + inline bool is_tx_busy(void) const { return m_tx_buffer.busy; } + inline bool is_tx_failed(void) const { return m_tx_buffer.error; } + inline bool is_rx_busy(bool second) const { return m_rx_buffers[second].busy; } + inline bool is_rx_failed(bool second) const { return m_rx_buffers[second].error; } - void SetCallback(IHsUsartCallback *callback, uintptr_t callbackParam); + void set_callback(ihs_usart_callback *callback, uintptr_t callback_param); private: - void BuildHeader(Packet &packet, uint8_t serialNo, uint8_t length); - bool CheckHeader(packet_header &header); - void SwitchRxBuffers(void); + void build_header(packet &packet, uint8_t serial_nr, uint8_t length); + bool check_header(packet_header &header); + void switch_rx_buffers(void); // UsartCore pure virtual function implementations - virtual void receiver_idle(void); - virtual void transmission_complete(void); - virtual void framing_error(void); - virtual void overrun(void); - virtual void rx_dma_transfer_complete(void); - virtual void rx_dma_half_transfer(void); - virtual void rx_dma_error(dma_helper::dma_error_type reason); - virtual void tx_dma_transfer_complete(void); - virtual void tx_dma_half_transfer(void); - virtual void tx_dma_error(dma_helper::dma_error_type reason); + virtual void receiver_idle(void) override; + virtual void transmission_complete(void) override; + virtual void framing_error(void) override; + virtual void overrun(void) override; + virtual void rx_dma_transfer_complete(void) override; + virtual void rx_dma_half_transfer(void) override; + virtual void rx_dma_error(dma_helper::dma_error_type reason) override; + virtual void tx_dma_transfer_complete(void) override; + virtual void tx_dma_half_transfer(void) override; + virtual void tx_dma_error(dma_helper::dma_error_type reason) override; struct Buffer { - Packet packet; + packet pkt; // transfer area ends here bool volatile busy = 0; bool volatile error = 0; - uint16_t requestedLength = 0; - uint32_t errorInfo = 0; + uint16_t requested_length = 0; + uint32_t error_info = 0; }; static const uint8_t STARTMARKER = 0x95; - uint8_t m_rxSerialNo = -1; - uint8_t m_txSerialNo = -1; - Stats m_stats; - bool m_rxBufferSelector = false; + uint8_t m_rx_serial_nr = -1; + uint8_t m_tx_serial_nr = -1; + stats m_stats; + bool m_rx_buffer_selector = false; - crc_handler::slot<2> m_crcSlot; - IHsUsartCallback *m_userCallback = nullptr; - uintptr_t m_userCallbackParam = 0; - Buffer m_txBuffer; - Buffer m_rxBuffers[2]; + crc_handler::slot<2> m_crc_slot; + ihs_usart_callback *m_user_callback = nullptr; + uintptr_t m_user_callback_param = 0; + Buffer m_tx_buffer; + Buffer m_rx_buffers[2]; }; } diff --git a/components/f4ll/src/console_handler.cpp b/components/f4ll/src/console_handler.cpp index 50efe7d..02c990f 100644 --- a/components/f4ll/src/console_handler.cpp +++ b/components/f4ll/src/console_handler.cpp @@ -53,7 +53,7 @@ void console_handler::PrintStats(uint8_t id, packet_usart &usart) { char ids[] = " : "; char *buffer = m_buffer; - packet_usart::Stats const &stats(usart.GetStats()); + packet_usart::stats const &stats(usart.get_stats()); ids[0] = id + '0'; buffer += strcpy_ex(buffer, ids); @@ -61,14 +61,14 @@ void console_handler::PrintStats(uint8_t id, packet_usart &usart) ADDINFO(buffer, " r: ", stats.rcvd); ADDINFO(buffer, " sk: ", stats.skiped); ADDINFO(buffer, " or: ", stats.overrun); - ADDINFO(buffer, " he: ", stats.hdrError); - ADDINFO(buffer, " pe: ", stats.payloadErrror); + ADDINFO(buffer, " he: ", stats.hdr_error); + ADDINFO(buffer, " pe: ", stats.payload_errror); buffer += strcpy_ex(buffer, ",0x"); buffer += uitohex(buffer, stats.pep1, 8); buffer += strcpy_ex(buffer, ",0x"); buffer += uitohex(buffer, stats.pep2, 8); - ADDINFO(buffer, " rde: ", stats.rxDmaError); - ADDINFO(buffer, " tde: ", stats.txDmaError); + ADDINFO(buffer, " rde: ", stats.rx_dma_error); + ADDINFO(buffer, " tde: ", stats.tx_dma_error); ADDINFO(buffer, " pmh: ", stats.premature_hdr); ADDINFO(buffer, " pmp: ", stats.premature_payload); buffer += strcpy_ex(buffer, "\r\n"); diff --git a/components/f4ll/src/packet_usart.cpp b/components/f4ll/src/packet_usart.cpp index 27e01bf..f56a0b6 100644 --- a/components/f4ll/src/packet_usart.cpp +++ b/components/f4ll/src/packet_usart.cpp @@ -14,54 +14,54 @@ template static inline T round_up_to_4(T input) return (input + 3) & (((T)-1) - 3); } -packet_usart::packet_usart(USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t streamRx, uint32_t streamTx) - : usart_core(usart, dma, streamRx, streamTx) +packet_usart::packet_usart(USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t stream_rx, uint32_t stream_tx) + : usart_core(usart, dma, stream_rx, stream_tx) { - crc_handler::instance().attach_slot(m_crcSlot); + crc_handler::instance().attach_slot(m_crc_slot); LL_USART_EnableIT_IDLE(usart); LL_USART_EnableIT_ERROR(usart); } -void packet_usart::RxProcessed(bool second) +void packet_usart::rx_processed(bool second) { - m_rxBuffers[second].busy = false; - m_rxBuffers[second].error = false; + m_rx_buffers[second].busy = false; + m_rx_buffers[second].error = false; } -void packet_usart::SetCallback(IHsUsartCallback *callback, uintptr_t callbackParam) +void packet_usart::set_callback(ihs_usart_callback *callback, uintptr_t callback_param) { - m_userCallback = callback; - m_userCallbackParam = callbackParam; + m_user_callback = callback; + m_user_callback_param = callback_param; } -void packet_usart::PostPacket(uint8_t const *payload, uint8_t length, bool wait_for_crc_queue) +void packet_usart::post_packet(uint8_t const *payload, uint8_t length, bool wait_for_crc_queue) { uint16_t payload_length = round_up_to_4((uint16_t)length); - BuildHeader(m_txBuffer.packet, m_txSerialNo++, length); + build_header(m_tx_buffer.pkt, m_tx_serial_nr++, length); if (payload) { - memcpy(m_txBuffer.packet.payload, payload, length); + memcpy(m_tx_buffer.pkt.payload, payload, length); } - m_txBuffer.requestedLength = sizeof(m_txBuffer.packet.header) + payload_length + sizeof(uint32_t); - m_txBuffer.busy = true; - m_txBuffer.error = false; + m_tx_buffer.requested_length = sizeof(m_tx_buffer.pkt.header) + payload_length + sizeof(uint32_t); + m_tx_buffer.busy = true; + m_tx_buffer.error = false; crc_handler::instance().enqueue( - m_crcSlot, 0, &m_txBuffer.packet, sizeof(packet_header) + payload_length, nullptr, - reinterpret_cast(m_txBuffer.packet.payload + payload_length)); + m_crc_slot, 0, &m_tx_buffer.pkt, sizeof(packet_header) + payload_length, nullptr, + reinterpret_cast(m_tx_buffer.pkt.payload + payload_length)); - while (wait_for_crc_queue && crc_handler::instance().is_queued(m_crcSlot, 0)) + while (wait_for_crc_queue && crc_handler::instance().is_queued(m_crc_slot, 0)) ; - setup_transmit(&m_txBuffer.packet, m_txBuffer.requestedLength); + setup_transmit(&m_tx_buffer.pkt, m_tx_buffer.requested_length); ++m_stats.sent; } -void packet_usart::SetupReceive() +void packet_usart::setup_receive() { - m_rxBuffers[m_rxBufferSelector].requestedLength = sizeof(m_rxBuffers[m_rxBufferSelector].packet); - usart_core::setup_receive(&m_rxBuffers[m_rxBufferSelector], sizeof(m_rxBuffers[m_rxBufferSelector].packet)); + m_rx_buffers[m_rx_buffer_selector].requested_length = sizeof(m_rx_buffers[m_rx_buffer_selector].pkt); + usart_core::setup_receive(&m_rx_buffers[m_rx_buffer_selector], sizeof(m_rx_buffers[m_rx_buffer_selector].pkt)); } ////////////////////////////////////// @@ -70,18 +70,19 @@ void packet_usart::SetupReceive() void packet_usart::receiver_idle(void) { - uint16_t rcvdLen = m_rxBuffers[m_rxBufferSelector].requestedLength - LL_DMA_GetDataLength(m_rx_dma.get_dma(), m_rx_dma.get_stream()); + uint16_t rcvdLen = + m_rx_buffers[m_rx_buffer_selector].requested_length - LL_DMA_GetDataLength(m_rx_dma.get_dma(), m_rx_dma.get_stream()); if (rcvdLen >= sizeof(packet_header)) { - if (CheckHeader(m_rxBuffers[m_rxBufferSelector].packet.header)) { - if (rcvdLen >= sizeof(packet_header) + round_up_to_4((uint16_t)m_rxBuffers[m_rxBufferSelector].packet.header.payload_length) + + if (check_header(m_rx_buffers[m_rx_buffer_selector].pkt.header)) { + if (rcvdLen >= sizeof(packet_header) + round_up_to_4((uint16_t)m_rx_buffers[m_rx_buffer_selector].pkt.header.payload_length) + sizeof(uint32_t)) { LL_DMA_DisableStream(m_rx_dma.get_dma(), m_rx_dma.get_stream()); } else { ++m_stats.premature_payload; } } else { - m_rxBuffers[m_rxBufferSelector].error = 1; + m_rx_buffers[m_rx_buffer_selector].error = 1; LL_DMA_DisableStream(m_rx_dma.get_dma(), m_rx_dma.get_stream()); } } else { @@ -93,7 +94,7 @@ void packet_usart::transmission_complete(void) { LL_USART_DisableDirectionTx(m_usart); // enforcing an idle frame LL_USART_EnableDirectionTx(m_usart); - m_txBuffer.busy = 0; + m_tx_buffer.busy = 0; } void packet_usart::framing_error(void) {} @@ -102,16 +103,16 @@ void packet_usart::overrun(void) {} void packet_usart::rx_dma_transfer_complete(void) { - if (CheckHeader(m_rxBuffers[m_rxBufferSelector].packet.header)) { + if (check_header(m_rx_buffers[m_rx_buffer_selector].pkt.header)) { crc_handler::instance().enqueue( - m_crcSlot, 1, &m_rxBuffers[m_rxBufferSelector].packet, - sizeof(packet_header) + round_up_to_4((uint16_t)m_rxBuffers[m_rxBufferSelector].packet.header.payload_length), this, - m_rxBufferSelector); + m_crc_slot, 1, &m_rx_buffers[m_rx_buffer_selector].pkt, + sizeof(packet_header) + round_up_to_4((uint16_t)m_rx_buffers[m_rx_buffer_selector].pkt.header.payload_length), this, + m_rx_buffer_selector); } else { - ++m_stats.hdrError; - m_rxBuffers[m_rxBufferSelector].error = true; + ++m_stats.hdr_error; + m_rx_buffers[m_rx_buffer_selector].error = true; } - SwitchRxBuffers(); + switch_rx_buffers(); } void packet_usart::rx_dma_half_transfer(void) {} @@ -120,9 +121,9 @@ void packet_usart::rx_dma_error(dma_helper::dma_error_type reason) { (void)reason; - m_rxBuffers[m_rxBufferSelector].error = 1; - ++m_stats.rxDmaError; - SwitchRxBuffers(); + m_rx_buffers[m_rx_buffer_selector].error = 1; + ++m_stats.rx_dma_error; + switch_rx_buffers(); } void packet_usart::tx_dma_transfer_complete(void) @@ -137,74 +138,74 @@ void packet_usart::tx_dma_error(dma_helper::dma_error_type reason) { (void)reason; - m_txBuffer.error = 1; - ++m_stats.txDmaError; + m_tx_buffer.error = 1; + ++m_stats.tx_dma_error; } /////////////////////// // Private functions // /////////////////////// -void packet_usart::BuildHeader(Packet &packet, uint8_t serialNo, uint8_t length) +void packet_usart::build_header(packet &packet, uint8_t serial_nr, uint8_t length) { uint8_t hash = STARTMARKER; packet.header.start_byte = STARTMARKER; - packet.header.serial = serialNo; - hash ^= serialNo; + packet.header.serial = serial_nr; + hash ^= serial_nr; packet.header.payload_length = length; hash ^= length; packet.header.hash = hash; } -bool packet_usart::CheckHeader(packet_header &header) +bool packet_usart::check_header(packet_header &header) { return header.start_byte == STARTMARKER && (header.start_byte ^ header.serial ^ header.payload_length) == header.hash; } -void packet_usart::SwitchRxBuffers(void) +void packet_usart::switch_rx_buffers(void) { ++m_stats.rcvd; - m_rxBufferSelector = !m_rxBufferSelector; + m_rx_buffer_selector = !m_rx_buffer_selector; - if (m_rxBuffers[m_rxBufferSelector].busy) { + if (m_rx_buffers[m_rx_buffer_selector].busy) { ++m_stats.overrun; } - SetupReceive(); + setup_receive(); } /////////////////////////// // crc_handler::ICallback // /////////////////////////// -void packet_usart::crc_succeeded(uintptr_t callbackParam, uint32_t crc, uint8_t task) +void packet_usart::crc_succeeded(uintptr_t callback_param, uint32_t crc, uint8_t task) { (void)task; - Buffer &buf(m_rxBuffers[static_cast(callbackParam)]); + Buffer &buf(m_rx_buffers[static_cast(callback_param)]); buf.busy = 1; - if (*(uint32_t *)(buf.packet.payload + round_up_to_4((uint16_t)buf.packet.header.payload_length)) != crc) { + if (*(uint32_t *)(buf.pkt.payload + round_up_to_4((uint16_t)buf.pkt.header.payload_length)) != crc) { buf.error = 1; - buf.errorInfo = crc; - ++m_stats.payloadErrror; + buf.error_info = crc; + ++m_stats.payload_errror; } - if (m_userCallback) { - buf.busy = !m_userCallback->PacketReceived(this, m_userCallbackParam, buf.packet); + if (m_user_callback) { + buf.busy = !m_user_callback->packet_received(this, m_user_callback_param, buf.pkt); } } -void packet_usart::crc_failed(uintptr_t callbackParam, uint32_t crc, uint8_t task) +void packet_usart::crc_failed(uintptr_t callback_param, uint32_t crc, uint8_t task) { (void)crc; (void)task; - Buffer &buf(m_rxBuffers[static_cast(callbackParam)]); + Buffer &buf(m_rx_buffers[static_cast(callback_param)]); buf.busy = buf.error = true; - buf.errorInfo = 0; - ++m_stats.payloadErrror; - if (m_userCallback) { - buf.busy = !m_userCallback->PacketReceived(this, m_userCallbackParam, buf.packet); + buf.error_info = 0; + ++m_stats.payload_errror; + if (m_user_callback) { + buf.busy = !m_user_callback->packet_received(this, m_user_callback_param, buf.pkt); } }