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 <typename T> 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<uintptr_t>(m_txBuffer.packet.payload + payload_length));
+        m_crc_slot, 0, &m_tx_buffer.pkt, sizeof(packet_header) + payload_length, nullptr,
+        reinterpret_cast<uintptr_t>(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<int>(callbackParam)]);
+    Buffer &buf(m_rx_buffers[static_cast<int>(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<int>(callbackParam)]);
+    Buffer &buf(m_rx_buffers[static_cast<int>(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);
     }
 }