playground-stm32/f407ve_hs_uart
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

tmp 5

Browse source
This commit is contained in:
Attila Body 2025-06-08 23:15:46 +02:00
parent 66c9d451ab
commit eaf7ebc191
Signed by: abody
GPG key ID: BD0C6214E68FB5CF
5 changed files with 128 additions and 127 deletions
Download patch file Download diff file Expand all files Collapse all files

20
components/f4ll/inc/f4ll/console_handler.h
View file

@ -24,16 +24,16 @@ 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);
// LL_UsartCore pure virtual function implementations // LL_UsartCore pure virtual function implementations
virtual void receiver_idle(void); virtual void receiver_idle(void) override;
virtual void transmission_complete(void); virtual void transmission_complete(void) override;
virtual void framing_error(void); virtual void framing_error(void) override;
virtual void overrun(void); virtual void overrun(void) override;
virtual void rx_dma_transfer_complete(void); virtual void rx_dma_transfer_complete(void) override;
virtual void rx_dma_half_transfer(void); virtual void rx_dma_half_transfer(void) override;
virtual void rx_dma_error(dma_helper::dma_error_type reason); virtual void rx_dma_error(dma_helper::dma_error_type reason) override;
virtual void tx_dma_transfer_complete(void); virtual void tx_dma_transfer_complete(void) override;
virtual void tx_dma_half_transfer(void); virtual void tx_dma_half_transfer(void) override;
virtual void tx_dma_error(dma_helper::dma_error_type reason); virtual void tx_dma_error(dma_helper::dma_error_type reason) override;
char m_buffer[128]; char m_buffer[128];
uint16_t m_used = 0; uint16_t m_used = 0;

10
components/f4ll/inc/f4ll/dma_helper.h
View file

@ -29,11 +29,11 @@ public:
inline uint32_t get_ht_mask() const { return m_ht_masks[m_stream]; } 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 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_ht() const { 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_te() const { 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_tc() const { 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_dme() const { 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_fe() const { return LL_DMA_IsEnabledIT_FE(m_dma, m_stream) != 0; }
enum class dma_error_type { transfer, direct_mode, fifo }; enum class dma_error_type { transfer, direct_mode, fifo };

94
components/f4ll/inc/f4ll/packet_usart.h
View file

@ -29,21 +29,21 @@ public:
uint8_t hash; uint8_t hash;
}; };
struct Packet struct packet
{ {
packet_header header; packet_header header;
uint8_t payload[256 + sizeof(uint32_t)]; // extra room for crc32 uint8_t payload[256 + sizeof(uint32_t)]; // extra room for crc32
} __attribute__((aligned)); } __attribute__((aligned));
struct Stats struct stats
{ {
uint32_t overrun = 0; uint32_t overrun = 0;
uint32_t hdrError = 0; uint32_t hdr_error = 0;
uint32_t payloadErrror = 0; uint32_t payload_errror = 0;
uint32_t pep1 = 0; uint32_t pep1 = 0;
uint32_t pep2 = 0; uint32_t pep2 = 0;
uint32_t rxDmaError = 0; uint32_t rx_dma_error = 0;
uint32_t txDmaError = 0; uint32_t tx_dma_error = 0;
uint32_t rcvd = 0; uint32_t rcvd = 0;
uint32_t premature_hdr = 0; uint32_t premature_hdr = 0;
uint32_t premature_payload = 0; uint32_t premature_payload = 0;
@ -51,71 +51,71 @@ public:
uint32_t skiped = 0; 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 // crc_handler::ICallback interface functions
virtual void crc_succeeded(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 callbackParam, uint32_t crc, uint8_t task); 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 post_packet(uint8_t const *payload, uint8_t length, bool wait_for_crc_queue = true);
void SetupReceive(void); void setup_receive(void);
void RxProcessed(bool second); void rx_processed(bool second);
// Getters // Getters
uint8_t *GetTxPacketBuffer(void) { return m_txBuffer.packet.payload; } uint8_t *get_tx_packet_buffer(void) { return m_tx_buffer.pkt.payload; }
uint8_t const *GetRxPacketBuffer(bool second) { return m_rxBuffers[second].packet.payload; } uint8_t const *get_rx_packet_buffer(bool second) { return m_rx_buffers[second].pkt.payload; }
USART_TypeDef *GetUsart(void) const { return m_usart; } USART_TypeDef *get_usart(void) const { return m_usart; }
Stats const &GetStats(void) const { return m_stats; } stats const &get_stats(void) const { return m_stats; }
inline bool IsTxBusy(void) const { return m_txBuffer.busy; } inline bool is_tx_busy(void) const { return m_tx_buffer.busy; }
inline bool IsTxFailed(void) const { return m_txBuffer.error; } inline bool is_tx_failed(void) const { return m_tx_buffer.error; }
inline bool IsRxBusy(bool second) const { return m_rxBuffers[second].busy; } inline bool is_rx_busy(bool second) const { return m_rx_buffers[second].busy; }
inline bool IsRxFailed(bool second) const { return m_rxBuffers[second].error; } 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: private:
void BuildHeader(Packet &packet, uint8_t serialNo, uint8_t length); void build_header(packet &packet, uint8_t serial_nr, uint8_t length);
bool CheckHeader(packet_header &header); bool check_header(packet_header &header);
void SwitchRxBuffers(void); void switch_rx_buffers(void);
// UsartCore pure virtual function implementations // UsartCore pure virtual function implementations
virtual void receiver_idle(void); virtual void receiver_idle(void) override;
virtual void transmission_complete(void); virtual void transmission_complete(void) override;
virtual void framing_error(void); virtual void framing_error(void) override;
virtual void overrun(void); virtual void overrun(void) override;
virtual void rx_dma_transfer_complete(void); virtual void rx_dma_transfer_complete(void) override;
virtual void rx_dma_half_transfer(void); virtual void rx_dma_half_transfer(void) override;
virtual void rx_dma_error(dma_helper::dma_error_type reason); virtual void rx_dma_error(dma_helper::dma_error_type reason) override;
virtual void tx_dma_transfer_complete(void); virtual void tx_dma_transfer_complete(void) override;
virtual void tx_dma_half_transfer(void); virtual void tx_dma_half_transfer(void) override;
virtual void tx_dma_error(dma_helper::dma_error_type reason); virtual void tx_dma_error(dma_helper::dma_error_type reason) override;
struct Buffer struct Buffer
{ {
Packet packet; packet pkt;
// transfer area ends here // transfer area ends here
bool volatile busy = 0; bool volatile busy = 0;
bool volatile error = 0; bool volatile error = 0;
uint16_t requestedLength = 0; uint16_t requested_length = 0;
uint32_t errorInfo = 0; uint32_t error_info = 0;
}; };
static const uint8_t STARTMARKER = 0x95; static const uint8_t STARTMARKER = 0x95;
uint8_t m_rxSerialNo = -1; uint8_t m_rx_serial_nr = -1;
uint8_t m_txSerialNo = -1; uint8_t m_tx_serial_nr = -1;
Stats m_stats; stats m_stats;
bool m_rxBufferSelector = false; bool m_rx_buffer_selector = false;
crc_handler::slot<2> m_crcSlot; crc_handler::slot<2> m_crc_slot;
IHsUsartCallback *m_userCallback = nullptr; ihs_usart_callback *m_user_callback = nullptr;
uintptr_t m_userCallbackParam = 0; uintptr_t m_user_callback_param = 0;
Buffer m_txBuffer; Buffer m_tx_buffer;
Buffer m_rxBuffers[2]; Buffer m_rx_buffers[2];
}; };
} }

10
components/f4ll/src/console_handler.cpp
View file

@ -53,7 +53,7 @@ void console_handler::PrintStats(uint8_t id, packet_usart &usart)
{ {
char ids[] = " : "; char ids[] = " : ";
char *buffer = m_buffer; char *buffer = m_buffer;
packet_usart::Stats const &stats(usart.GetStats()); packet_usart::stats const &stats(usart.get_stats());
ids[0] = id + '0'; ids[0] = id + '0';
buffer += strcpy_ex(buffer, ids); 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, " r: ", stats.rcvd);
ADDINFO(buffer, " sk: ", stats.skiped); ADDINFO(buffer, " sk: ", stats.skiped);
ADDINFO(buffer, " or: ", stats.overrun); ADDINFO(buffer, " or: ", stats.overrun);
ADDINFO(buffer, " he: ", stats.hdrError); ADDINFO(buffer, " he: ", stats.hdr_error);
ADDINFO(buffer, " pe: ", stats.payloadErrror); ADDINFO(buffer, " pe: ", stats.payload_errror);
buffer += strcpy_ex(buffer, ",0x"); buffer += strcpy_ex(buffer, ",0x");
buffer += uitohex(buffer, stats.pep1, 8); buffer += uitohex(buffer, stats.pep1, 8);
buffer += strcpy_ex(buffer, ",0x"); buffer += strcpy_ex(buffer, ",0x");
buffer += uitohex(buffer, stats.pep2, 8); buffer += uitohex(buffer, stats.pep2, 8);
ADDINFO(buffer, " rde: ", stats.rxDmaError); ADDINFO(buffer, " rde: ", stats.rx_dma_error);
ADDINFO(buffer, " tde: ", stats.txDmaError); ADDINFO(buffer, " tde: ", stats.tx_dma_error);
ADDINFO(buffer, " pmh: ", stats.premature_hdr); ADDINFO(buffer, " pmh: ", stats.premature_hdr);
ADDINFO(buffer, " pmp: ", stats.premature_payload); ADDINFO(buffer, " pmp: ", stats.premature_payload);
buffer += strcpy_ex(buffer, "\r\n"); buffer += strcpy_ex(buffer, "\r\n");

121
components/f4ll/src/packet_usart.cpp
View file

@ -14,54 +14,54 @@ template <typename T> static inline T round_up_to_4(T input)
return (input + 3) & (((T)-1) - 3); return (input + 3) & (((T)-1) - 3);
} }
packet_usart::packet_usart(USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t streamRx, uint32_t streamTx) packet_usart::packet_usart(USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t stream_rx, uint32_t stream_tx)
: usart_core(usart, dma, streamRx, streamTx) : 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_IDLE(usart);
LL_USART_EnableIT_ERROR(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_rx_buffers[second].busy = false;
m_rxBuffers[second].error = 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_user_callback = callback;
m_userCallbackParam = callbackParam; 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); 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) { 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_tx_buffer.requested_length = sizeof(m_tx_buffer.pkt.header) + payload_length + sizeof(uint32_t);
m_txBuffer.busy = true; m_tx_buffer.busy = true;
m_txBuffer.error = false; m_tx_buffer.error = false;
crc_handler::instance().enqueue( crc_handler::instance().enqueue(
m_crcSlot, 0, &m_txBuffer.packet, sizeof(packet_header) + payload_length, nullptr, m_crc_slot, 0, &m_tx_buffer.pkt, sizeof(packet_header) + payload_length, nullptr,
reinterpret_cast<uintptr_t>(m_txBuffer.packet.payload + payload_length)); 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; ++m_stats.sent;
} }
void packet_usart::SetupReceive() void packet_usart::setup_receive()
{ {
m_rxBuffers[m_rxBufferSelector].requestedLength = 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_rxBuffers[m_rxBufferSelector], sizeof(m_rxBuffers[m_rxBufferSelector].packet)); 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) 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 (rcvdLen >= sizeof(packet_header)) {
if (CheckHeader(m_rxBuffers[m_rxBufferSelector].packet.header)) { if (check_header(m_rx_buffers[m_rx_buffer_selector].pkt.header)) {
if (rcvdLen >= sizeof(packet_header) + round_up_to_4((uint16_t)m_rxBuffers[m_rxBufferSelector].packet.header.payload_length) + 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)) { sizeof(uint32_t)) {
LL_DMA_DisableStream(m_rx_dma.get_dma(), m_rx_dma.get_stream()); LL_DMA_DisableStream(m_rx_dma.get_dma(), m_rx_dma.get_stream());
} else { } else {
++m_stats.premature_payload; ++m_stats.premature_payload;
} }
} else { } 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()); LL_DMA_DisableStream(m_rx_dma.get_dma(), m_rx_dma.get_stream());
} }
} else { } else {
@ -93,7 +94,7 @@ void packet_usart::transmission_complete(void)
{ {
LL_USART_DisableDirectionTx(m_usart); // enforcing an idle frame LL_USART_DisableDirectionTx(m_usart); // enforcing an idle frame
LL_USART_EnableDirectionTx(m_usart); LL_USART_EnableDirectionTx(m_usart);
m_txBuffer.busy = 0; m_tx_buffer.busy = 0;
} }
void packet_usart::framing_error(void) {} void packet_usart::framing_error(void) {}
@ -102,16 +103,16 @@ void packet_usart::overrun(void) {}
void packet_usart::rx_dma_transfer_complete(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( crc_handler::instance().enqueue(
m_crcSlot, 1, &m_rxBuffers[m_rxBufferSelector].packet, m_crc_slot, 1, &m_rx_buffers[m_rx_buffer_selector].pkt,
sizeof(packet_header) + round_up_to_4((uint16_t)m_rxBuffers[m_rxBufferSelector].packet.header.payload_length), this, sizeof(packet_header) + round_up_to_4((uint16_t)m_rx_buffers[m_rx_buffer_selector].pkt.header.payload_length), this,
m_rxBufferSelector); m_rx_buffer_selector);
} else { } else {
++m_stats.hdrError; ++m_stats.hdr_error;
m_rxBuffers[m_rxBufferSelector].error = true; m_rx_buffers[m_rx_buffer_selector].error = true;
} }
SwitchRxBuffers(); switch_rx_buffers();
} }
void packet_usart::rx_dma_half_transfer(void) {} 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; (void)reason;
m_rxBuffers[m_rxBufferSelector].error = 1; m_rx_buffers[m_rx_buffer_selector].error = 1;
++m_stats.rxDmaError; ++m_stats.rx_dma_error;
SwitchRxBuffers(); switch_rx_buffers();
} }
void packet_usart::tx_dma_transfer_complete(void) 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; (void)reason;
m_txBuffer.error = 1; m_tx_buffer.error = 1;
++m_stats.txDmaError; ++m_stats.tx_dma_error;
} }
/////////////////////// ///////////////////////
// Private functions // // 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; uint8_t hash = STARTMARKER;
packet.header.start_byte = STARTMARKER; packet.header.start_byte = STARTMARKER;
packet.header.serial = serialNo; packet.header.serial = serial_nr;
hash ^= serialNo; hash ^= serial_nr;
packet.header.payload_length = length; packet.header.payload_length = length;
hash ^= length; hash ^= length;
packet.header.hash = hash; 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; 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_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; ++m_stats.overrun;
} }
SetupReceive(); setup_receive();
} }
/////////////////////////// ///////////////////////////
// crc_handler::ICallback // // 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; (void)task;
Buffer &buf(m_rxBuffers[static_cast<int>(callbackParam)]); Buffer &buf(m_rx_buffers[static_cast<int>(callback_param)]);
buf.busy = 1; 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.error = 1;
buf.errorInfo = crc; buf.error_info = crc;
++m_stats.payloadErrror; ++m_stats.payload_errror;
} }
if (m_userCallback) { if (m_user_callback) {
buf.busy = !m_userCallback->PacketReceived(this, m_userCallbackParam, buf.packet); 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)crc;
(void)task; (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.busy = buf.error = true;
buf.errorInfo = 0; buf.error_info = 0;
++m_stats.payloadErrror; ++m_stats.payload_errror;
if (m_userCallback) { if (m_user_callback) {
buf.busy = !m_userCallback->PacketReceived(this, m_userCallbackParam, buf.packet); buf.busy = !m_user_callback->packet_received(this, m_user_callback_param, buf.pkt);
} }
} }