Welding/sitara_depot
25
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix(SF-60): Багфиксы, багфиксы, багфиксы

Browse Source
This commit is contained in:
algin 2023-10-26 10:21:41 +03:00
parent 6f3fe15497
commit 87ccf2c5cc
19 changed files with 181 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
components/free_rtos/ethernet/eth_tx_flow.cpp
View File

@ -32,7 +32,7 @@ static void eth_initTxFreePktQ(void * appPriv, EnetDma_PktQ * p_packet_queue)
uint32_t i;
/// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int i_max = ENET_SYSCFG_TOTAL_NUM_TX_PKT;
int i_max = (ENET_SYSCFG_TOTAL_NUM_TX_PKT);
/* Initialize TX EthPkts and queue them to txFreePktInfoQ */
for (i = 0U; i < i_max; i++)
@ -125,7 +125,7 @@ bool free_rtos::EthTxFlow::open(uint32_t id, int32_t enetDmaTxChId)
dma_handle_ = txChInfo.hTxCh;
EnetAppUtils_assert(txChInfo.useGlobalEvt == true);
EnetAppUtils_assert(txChInfo.maxNumTxPkts >= ENET_SYSCFG_TOTAL_NUM_TX_PKT);
EnetAppUtils_assert(txChInfo.maxNumTxPkts >= (ENET_SYSCFG_TOTAL_NUM_TX_PKT));
if (dma_handle_ == nullptr)
{
@ -173,16 +173,12 @@ bool free_rtos::EthTxFlow::send(TEthMacPorts port_id, uint8_t * p_data, uint32_t
EnetDma_Pkt *txPktInfo;
int32_t status;
/*
* <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> enet <EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD> <EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> txFreePktInfoQ
*/
eth_retrieveFreeTxPkts(&dma_handle_, &tx_free_pktq_);
/// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> txSubmitQ
EnetQueue_initQ(&txSubmitQ);
/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> TX Eth */
eth_retrieveFreeTxPkts(&dma_handle_, &tx_free_pktq_);
txPktInfo = (EnetDma_Pkt *)EnetQueue_deq(&tx_free_pktq_);
if (txPktInfo != NULL)
{
///<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD>
@ -227,10 +223,12 @@ bool free_rtos::EthTxFlow::send(TEthMacPorts port_id, uint8_t * p_data, uint32_t
bool free_rtos::EthTxFlow::send(TxFlowHandlerArgs& handlerArgs, uint32_t numScatterSegments)
{
if (handlerArgs.port_id >= e_ethMacTotal) {
EnetAppUtils_print("Wrong port id\r\n");
return false;
}
if (!port_data_[handlerArgs.port_id].tx_enable) {
if (port_data_[handlerArgs.port_id].tx_enable == false) {
return false;
}
@ -238,24 +236,25 @@ bool free_rtos::EthTxFlow::send(TxFlowHandlerArgs& handlerArgs, uint32_t numScat
EnetDma_Pkt *txPktInfo;
int32_t status;
eth_retrieveFreeTxPkts(&dma_handle_, &tx_free_pktq_);
EnetQueue_initQ(&txSubmitQ);
eth_retrieveFreeTxPkts(&dma_handle_, &tx_free_pktq_);
txPktInfo = (EnetDma_Pkt *)EnetQueue_deq(&tx_free_pktq_);
if (txPktInfo != NULL)
{
for(size_t scatter_segment = 0; scatter_segment < numScatterSegments; scatter_segment++)
{
handlerArgs.buffer = txPktInfo->sgList.list[scatter_segment].bufPtr;
txPktInfo->sgList.list[scatter_segment].segmentFilledLen = handlerArgs.stack_handler->Sender(handlerArgs, scatter_segment);
txPktInfo->sgList.list[scatter_segment].segmentFilledLen = handlerArgs.stack_handler->Sender(handlerArgs, 0);
}
txPktInfo->sgList.numScatterSegments = numScatterSegments;
txPktInfo->sgList.numScatterSegments = 1;
txPktInfo->chkSumInfo = 0U;
txPktInfo->appPriv = nullptr;
txPktInfo->tsInfo.txPktSeqId = 0;
txPktInfo->txPktTc = 0; /// Traffic class <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> IPv6
txPktInfo->txPktTc = 0; /// Traffic class IPv6
txPktInfo->tsInfo.enableHostTxTs = false;
txPktInfo->txPortNum = (Enet_MacPort)handlerArgs.port_id;

2
components/free_rtos/ethernet_industry/eth_ecat.cpp
View File

@ -20,7 +20,7 @@ EthEcat::EthEcat(Eth& eth)
void EthEcat::Init(TEthMacPorts port_id, uint32_t period_microsec = 250) {
port_id_ = port_id;
telegram_.init(port_id, period_microsec, 6);
telegram_.init(port_id, period_microsec, 4);
Timer::Settings ecat_tmr_sett = {
.input_clk_Hz = 25000000, // 25MHz

3
components/free_rtos/ethernet_industry/eth_ecat_telegram.cpp
View File

@ -51,7 +51,7 @@ int32_t EcatTelegram::Process(uint8_t *p_data, uint32_t len) {
return 0;
}
uint32_t EcatTelegram::Sender(HandlerArgs& handlerArgs, size_t scatter_segment) {
uint16_t EcatTelegram::Sender(HandlerArgs& handlerArgs, size_t scatter_segment) {
uint8_t *raw = pack(handlerArgs.buffer);
//DebugP_log((char*)"Sender started\r\n");
@ -118,6 +118,7 @@ bool EcatTelegram::transfer() {
txFlowHandlerArgs.port_id = port_id_;
txFlowHandlerArgs.stack_handler = this;
txFlowHandlerArgs.buffer = nullptr;
while(1) {
tick_counter_start = ecat_timer_.Wait();

2
components/free_rtos/ethernet_industry/eth_ecat_telegram.hpp
View File

@ -66,7 +66,7 @@ public:
}
virtual int32_t Process(uint8_t *p_data, uint32_t len) override;
virtual uint32_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) override;
virtual uint16_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) override;
void init(TEthMacPorts port_id, uint32_t period_microsec, uint32_t max_transfer_attempts) {
port_id_ = port_id;

2
components/free_rtos/ethernet_ip/eth_arp.cpp
View File

@ -205,7 +205,7 @@ int32_t free_rtos::EthArp::Process(uint8_t * p_data, uint32_t len)
return 0;
}
uint32_t free_rtos::EthArp::Sender(HandlerArgs& handlerArgs, size_t scatter_segment)
uint16_t free_rtos::EthArp::Sender(HandlerArgs& handlerArgs, size_t scatter_segment)
{
return 0;
}

2
components/free_rtos/ethernet_ip/eth_arp.hpp
View File

@ -32,7 +32,7 @@ public:
bool try_request(uint32_t ip);
virtual int32_t Process(uint8_t * p_data, uint32_t len) override;
virtual uint32_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) override;
virtual uint16_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) override;
private:
bool request(uint32_t ip);

27
components/free_rtos/ethernet_ip/eth_checksum.c
View File

@ -25,3 +25,30 @@ uint16_t eth_calcChksum(uint32_t sum, uint8_t * const data, uint16_t len)
return ~sum;
}
uint16_t eth_calcChksum2(uint32_t sum, uint8_t * const hdata, uint16_t hlen, uint8_t * const data, uint16_t len)
{
uint16_t i;
uint16_t hsize = hlen - 1;
uint16_t size = len - 1;
if ( (hlen == 0) || (len == 0) )
return 0;
for ( i = 0; i < hsize; i+=2 )
sum += ((uint16_t)hdata[i] << 8) + hdata[i+1];
if (hlen & 0x01)
sum += (uint16_t)hdata[i] << 8;
for ( i = 0; i < size; i+=2 )
sum += ((uint16_t)data[i] << 8) + data[i+1];
if (len & 0x01)
sum += (uint16_t)data[i] << 8;
while ( sum >> 16 )
sum = (sum & 0xFFFF) + (sum >> 16);
return ~sum;
}

1
components/free_rtos/ethernet_ip/eth_checksum.h
View File

@ -15,6 +15,7 @@ extern "C" {
#endif
uint16_t eth_calcChksum(uint32_t sum, uint8_t * const data, uint16_t len);
uint16_t eth_calcChksum2(uint32_t sum, uint8_t * const hdata, uint16_t hlen, uint8_t * const data, uint16_t len);
#ifdef __cplusplus
}

2
components/free_rtos/ethernet_ip/eth_icmp.cpp
View File

@ -40,7 +40,7 @@ int32_t free_rtos::EthIcmp::Process(uint8_t * p_data, uint32_t len)
return len;
}
uint32_t free_rtos::EthIcmp::Sender(HandlerArgs& handlerArgs, size_t scatter_segment)
uint16_t free_rtos::EthIcmp::Sender(HandlerArgs& handlerArgs, size_t scatter_segment)
{
return 0;
}

2
components/free_rtos/ethernet_ip/eth_icmp.hpp
View File

@ -18,7 +18,7 @@ namespace free_rtos {
class EthIcmp : public Handler {
public:
virtual int32_t Process(uint8_t * p_data, uint32_t len) override;
virtual uint32_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) override;
virtual uint16_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) override;
uint32_t getStat() {return rx_cnt_;};
private:

74
components/free_rtos/ethernet_ip/eth_ip.cpp
View File

@ -89,14 +89,44 @@ bool free_rtos::EthIp::send(TEthMacPorts port_id, uint32_t dest_ip, uint8_t prot
return eth_stack_.send_pkt(port_id, mac_dst, ETH_PROT_IP_BE, pkt);
}
inline uint16_t free_rtos::EthIp::fillIpHeader(IpHandlerArgs& ipHandlerArgs)
{
static_assert(sizeof(TIpHeader) == (IP_HEADER_WORD_SIZE * 4), "Ip header size doesn't match version !");
uint16_t ip_len = sizeof(TIpHeader) + ipHandlerArgs.ip_header_len + ipHandlerArgs.ip_data_len;
uint16_t cksum = 0;
memcpy(ipHandlerArgs.ip_header.ip_src, &self_ip_, ETH_IP_ADDR_LEN);
memcpy(ipHandlerArgs.ip_header.ip_dst, &ipHandlerArgs.dest_ip, ETH_IP_ADDR_LEN);
ipHandlerArgs.ip_header.ip_hl_v = (IP_VER << 4) | IP_HEADER_WORD_SIZE;
ipHandlerArgs.ip_header.ip_tos = 0;
ipHandlerArgs.ip_header.ip_len = BASE_SWAP16(ip_len);
ipHandlerArgs.ip_header.ip_id = BASE_SWAP16(ip_indet_);
ipHandlerArgs.ip_header.ip_off = 0;
ipHandlerArgs.ip_header.ip_ttl = IP_TIME_TO_LIVE;
ipHandlerArgs.ip_header.ip_p = ipHandlerArgs.ip_prot_id;
ipHandlerArgs.ip_header.ip_sum = 0;
cksum = eth_calcChksum(0, (uint8_t *)&ipHandlerArgs.ip_header, sizeof(TIpHeader));
ipHandlerArgs.ip_header.ip_sum = BASE_SWAP16(cksum);
++ip_indet_;
return sizeof(TIpHeader);
}
bool free_rtos::EthIp::send(IpHandlerArgs& handlerArgs)
{
handlerArgs.stack_handler = this;
fillIpHeader(handlerArgs);
return eth_stack_.send_pkt(handlerArgs);
}
inline uint32_t free_rtos::EthIp::fillEthFrameHeader(IpHandlerArgs& ipHandlerArgs)
inline uint16_t free_rtos::EthIp::fillEthFrameHeader(IpHandlerArgs& ipHandlerArgs)
{
TEthFrameHeader * p_eth_hdr = (TEthFrameHeader *)ipHandlerArgs.buffer;
uint64_t mac_dst;
@ -105,7 +135,7 @@ inline uint32_t free_rtos::EthIp::fillEthFrameHeader(IpHandlerArgs& ipHandlerArg
return 0;
}
p_eth_hdr->prot_id = ipHandlerArgs.ip_prot_id;
p_eth_hdr->prot_id = ETH_PROT_IP_BE;
memcpy(p_eth_hdr->mac_src, &self_mac_, ETH_FRAME_MAC_ADDR_LEN_BYTES);
memcpy(p_eth_hdr->mac_dest, &mac_dst, ETH_FRAME_MAC_ADDR_LEN_BYTES);
@ -113,46 +143,20 @@ inline uint32_t free_rtos::EthIp::fillEthFrameHeader(IpHandlerArgs& ipHandlerArg
return sizeof(TEthFrameHeader);
}
inline uint32_t free_rtos::EthIp::fillIpHeader(IpHandlerArgs& ipHandlerArgs, uint32_t ip_len)
uint16_t free_rtos::EthIp::Sender(HandlerArgs& handlerArgs, size_t scatter_segment)
{
TIpHeader * ip_header = (TIpHeader *)(ipHandlerArgs.buffer + sizeof(TEthFrameHeader));
uint16_t cksum = 0;
memcpy(ip_header->ip_src, &self_ip_, ETH_IP_ADDR_LEN);
memcpy(ip_header->ip_dst, &ipHandlerArgs.dest_ip, ETH_IP_ADDR_LEN);
ip_header->ip_hl_v = (IP_VER << 4) | IP_HEADER_WORD_SIZE;
ip_header->ip_tos = 0;
ip_header->ip_len = BASE_SWAP16(ip_len);
ip_header->ip_id = BASE_SWAP16(ip_indet_);
ip_header->ip_off = 0;
ip_header->ip_ttl = IP_TIME_TO_LIVE;
ip_header->ip_p = ipHandlerArgs.ip_prot_id;
ip_header->ip_sum = 0;
cksum = eth_calcChksum(0, (uint8_t *)ip_header, sizeof(TIpHeader));
ip_header->ip_sum = BASE_SWAP16(cksum);
++ip_indet_;
return sizeof(TIpHeader);
}
uint32_t free_rtos::EthIp::Sender(HandlerArgs& handlerArgs, size_t scatter_segment)
{
static_assert(sizeof(TIpHeader) == (IP_HEADER_WORD_SIZE * 4), "Ip header size doesn't match version !");
IpHandlerArgs& ipHandlerArgs = static_cast<IpHandlerArgs&>(handlerArgs); // downcasting back to derived type
uint32_t ip_len = ipHandlerArgs.ip_handler->Sender(ipHandlerArgs, scatter_segment);
if(fillEthFrameHeader(ipHandlerArgs) == 0) {
return 0;
//EnetAppUtils_print("Cannot find destination mac\r\n");
}
fillIpHeader(ipHandlerArgs, ip_len);
TIpHeader * ip_header = (TIpHeader *)(ipHandlerArgs.buffer + sizeof(TEthFrameHeader));
*ip_header = ipHandlerArgs.ip_header;
return sizeof(TEthFrameHeader) + sizeof(TIpHeader) + ip_len;
ipHandlerArgs.ip_handler->Sender(ipHandlerArgs, scatter_segment);
return sizeof(TEthFrameHeader) + sizeof(TIpHeader) + ipHandlerArgs.ip_header_len + ipHandlerArgs.ip_data_len;
}
int32_t free_rtos::EthIp::Process(uint8_t * p_data, uint32_t len)

6
components/free_rtos/ethernet_ip/eth_ip.hpp
View File

@ -33,7 +33,7 @@ public:
virtual bool send(IpHandlerArgs& handlerArgs) override;
virtual int32_t Process(uint8_t * p_data, uint32_t len) override;
virtual uint32_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) override;
virtual uint16_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) override;
bool Register(uint8_t prot_id, Handler * p_handler);
@ -48,8 +48,8 @@ private:
uint16_t ip_indet_; /// \u043f\u0457\u0405\u043f\u0457\u0405\u043f\u0457\u0405\u043f\u0457\u0405 ip_id
inline uint32_t fillEthFrameHeader(IpHandlerArgs& ipHandlerArgs);
inline uint32_t fillIpHeader(IpHandlerArgs& ipHandlerArgs, uint32_t ip_len);
inline uint16_t fillIpHeader(IpHandlerArgs& handlerArgs);
inline uint16_t fillEthFrameHeader(IpHandlerArgs& ipHandlerArgs);
};
}

4
components/free_rtos/ethernet_ip/eth_ip_iface.hpp
View File

@ -11,12 +11,16 @@
#include <cstdint>
#include "free_rtos/ethernet/eth_types.h"
#include "free_rtos/ethernet/eth_frame.h"
#include "free_rtos/ethernet_ip/eth_ip_types.h"
#include "free_rtos/ethernet_ip/eth_stack_iface.hpp"
struct IpHandlerArgs : public EthStackHandlerArgs {
uint16_t ip_header_len;
uint16_t ip_data_len;
uint32_t dest_ip;
uint8_t ip_prot_id;
Handler* ip_handler;
TIpHeader ip_header;
};
class EthIpIface {

2
components/free_rtos/ethernet_ip/eth_stack.cpp
View File

@ -66,7 +66,7 @@ bool free_rtos::EthStack::send_pkt(TEthMacPorts port_id, uint64_t mac_dst, uint1
bool free_rtos::EthStack::send_pkt(EthStackHandlerArgs& handlerArgs)
{
handlerArgs.port_id = eth_.mac_port_; // overwriting
//handlerArgs.port_id = eth_.mac_port_; // overwriting
return tx_flow_.send(handlerArgs, 1);
}

111
components/free_rtos/ethernet_ip/eth_udp_client.cpp
View File

@ -6,7 +6,6 @@
*/
#include "free_rtos/ethernet_ip/eth_udp_client.hpp"
#include "free_rtos/base/swap.h"
#include "free_rtos/ethernet_ip/eth_udp_types.h"
#include "free_rtos/ethernet_ip/eth_ip_types.h"
#include "free_rtos/ethernet_ip/eth_checksum.h"
#include "free_rtos/ethernet_ip/eth_ip_prots_id.h"
@ -50,10 +49,10 @@ void free_rtos::EthUpdClient::put_data(uint8_t * p_data, uint32_t len)
rx_sem_.post();
}
int32_t free_rtos::EthUpdClient::get_data(uint8_t * p_data, uint32_t len)
size_t free_rtos::EthUpdClient::get_data(uint8_t * p_data, uint32_t len)
{
std::vector<uint8_t>& buff = buff_[out_toggle_];
uint32_t size = buff.size();
size_t size = buff.size();
if (size > len) {
size = len;
@ -74,23 +73,25 @@ bool free_rtos::EthUpdClient::capture_buffer()
UDPToggle expected = static_cast<UDPToggle>((desired + 1)%UDPToggle::UDP_BUF_NUM);
if(in_toggle_.compare_exchange_weak(expected, desired) == false) {
return true;
return false;
}
out_toggle_ = expected;
return buff_[expected].empty();
return true;
}
size_t free_rtos::EthUpdClient::get_data_size()
{
if (buff_[out_toggle_].empty() == true) {
if(capture_buffer() == true) {
return 0;
size_t size = buff_[out_toggle_].size();
if (size == 0) {
if(capture_buffer() != false) {
size = buff_[out_toggle_].size();
}
}
return buff_[out_toggle_].size();
return size;
}
int32_t free_rtos::EthUpdClient::read(uint8_t * p_data, uint32_t len)
@ -99,8 +100,8 @@ int32_t free_rtos::EthUpdClient::read(uint8_t * p_data, uint32_t len)
return 0;
}
if(buff_[out_toggle_].empty() == true) {
while (capture_buffer() == true) {
if(buff_[out_toggle_].size() == 0) {
while (capture_buffer() == false) {
rx_sem_.pend();
}
}
@ -114,8 +115,8 @@ int32_t free_rtos::EthUpdClient::read_async(uint8_t * p_data, uint32_t len)
return 0;
}
if (buff_[out_toggle_].empty() == true) {
if(capture_buffer() == true) {
if (buff_[out_toggle_].size() == 0) {
if(capture_buffer() == false) {
return 0;
}
}
@ -126,7 +127,14 @@ int32_t free_rtos::EthUpdClient::read_async(uint8_t * p_data, uint32_t len)
void free_rtos::EthUpdClient::clear()
{
buff_[out_toggle_].clear();
while (capture_buffer() == false) {
rx_sem_.pend();
}
buff_[out_toggle_].clear();
}
/*
bool free_rtos::EthUpdClient::write(uint32_t ip_dst_be, uint8_t * p_data, uint32_t len)
{
@ -169,42 +177,18 @@ bool free_rtos::EthUpdClient::write(uint32_t ip_dst_be, uint8_t * p_data, uint32
return ip_iface_.send(port_id_, ip_dst_be, IP_PROT_UDP, eth_pkt_);
}
*/
bool free_rtos::EthUpdClient::write(uint32_t ip_dst_be, uint8_t * p_data, uint32_t len)
{
UDPHandlerArgs udpHandlerArgs;
udpHandlerArgs.port_id = port_id_;
udpHandlerArgs.dest_ip = ip_dst_be;
udpHandlerArgs.ip_prot_id = IP_PROT_UDP;
udpHandlerArgs.ip_handler = this;
udpHandlerArgs.p_data = p_data;
udpHandlerArgs.len = len;
uint16_t free_rtos::EthUpdClient::fill_udp_header(UDPHandlerArgs& udpHandlerArgs) {
uint16_t udp_len = udpHandlerArgs.ip_header_len + udpHandlerArgs.ip_data_len;
return ip_iface_.send(udpHandlerArgs);
}
uint32_t free_rtos::EthUpdClient::Sender(HandlerArgs& handlerArgs, size_t scatter_segment)
{
UDPHandlerArgs& udpHandlerArgs = static_cast<UDPHandlerArgs&>(handlerArgs); // downcasting back to derived type
TUdpHeader * hdr = (TUdpHeader *)(udpHandlerArgs.buffer + sizeof(TEthFrameHeader) + sizeof(TIpHeader));
uint8_t * p_udp_data = (uint8_t *)(udpHandlerArgs.buffer + sizeof(TEthFrameHeader) + sizeof(TIpHeader) + sizeof(TUdpHeader));
uint32_t udp_len = udpHandlerArgs.len + sizeof(TUdpHeader);
if (udpHandlerArgs.dest_ip == 0) {
udpHandlerArgs.dest_ip = src_ip_;
}
hdr->Src_port = port_src_be_;
hdr->Dst_port = port_dst_be_;
hdr->Length = BASE_SWAP16(udp_len);
hdr->Chk_sum = 0;
memcpy(p_udp_data, udpHandlerArgs.p_data, udpHandlerArgs.len);
udpHandlerArgs.udp_header.Src_port = port_src_be_;
udpHandlerArgs.udp_header.Dst_port = port_dst_be_;
udpHandlerArgs.udp_header.Length = BASE_SWAP16(udp_len);
udpHandlerArgs.udp_header.Chk_sum = 0;
if (use_checksum_) {
uint32_t self_ip = ip_iface_.getSelfIpAddr();
uint32_t chk_sum32 = 0;
uint8_t * const dst_ip = (uint8_t *)&udpHandlerArgs.dest_ip;
uint8_t * const src_ip = (uint8_t *)&self_ip;
@ -216,12 +200,47 @@ uint32_t free_rtos::EthUpdClient::Sender(HandlerArgs& handlerArgs, size_t scatte
chk_sum32 += IP_PROT_UDP + udp_len;
uint16_t chk_sum16 = eth_calcChksum(chk_sum32, (uint8_t *)hdr, udp_len);
uint16_t chk_sum16 = eth_calcChksum2(chk_sum32, (uint8_t *)&udpHandlerArgs.udp_header, sizeof(TUdpHeader), (uint8_t *)udpHandlerArgs.p_data, udpHandlerArgs.ip_data_len);
hdr->Chk_sum = BASE_SWAP16(chk_sum16);
udpHandlerArgs.udp_header.Chk_sum = BASE_SWAP16(chk_sum16);
}
return udp_len;
return sizeof(TUdpHeader);
}
bool free_rtos::EthUpdClient::write(uint32_t ip_dst_be, uint8_t * p_data, uint32_t len)
{
UDPHandlerArgs udpHandlerArgs;
if (ip_dst_be == 0) {
ip_dst_be = src_ip_;
}
//udpHandlerArgs.buffer = nullptr;
udpHandlerArgs.port_id = port_id_;
//udpHandlerArgs.stack_handler = nullptr;
udpHandlerArgs.ip_header_len = sizeof(TUdpHeader);
udpHandlerArgs.ip_data_len = len;
udpHandlerArgs.dest_ip = ip_dst_be;
udpHandlerArgs.ip_prot_id = IP_PROT_UDP;
udpHandlerArgs.ip_handler = this;
udpHandlerArgs.p_data = p_data;
fill_udp_header(udpHandlerArgs);
return ip_iface_.send(udpHandlerArgs);
}
uint16_t free_rtos::EthUpdClient::Sender(HandlerArgs& handlerArgs, size_t scatter_segment)
{
UDPHandlerArgs& udpHandlerArgs = static_cast<UDPHandlerArgs&>(handlerArgs); // downcasting back to derived type
TUdpHeader * hdr = (TUdpHeader *)(udpHandlerArgs.buffer + sizeof(TEthFrameHeader) + sizeof(TIpHeader));
uint8_t * p_udp_data = (uint8_t *)(udpHandlerArgs.buffer + sizeof(TEthFrameHeader) + sizeof(TIpHeader) + sizeof(TUdpHeader));
*hdr = udpHandlerArgs.udp_header;
memcpy(p_udp_data, udpHandlerArgs.p_data, udpHandlerArgs.ip_data_len);
return udpHandlerArgs.ip_header_len + udpHandlerArgs.ip_data_len;
}
int32_t free_rtos::EthUpdClient::Process(uint8_t * p_data, uint32_t len)

26
components/free_rtos/ethernet_ip/eth_udp_client.hpp
View File

@ -21,13 +21,14 @@
#include "free_rtos/ethernet/eth_frame.h"
#include "free_rtos/ethernet_ip/eth_ip_iface.hpp"
#include "free_rtos/ethernet/eth_types.h"
#include "free_rtos/ethernet_ip/eth_udp_types.h"
#include "free_rtos/handler_store/handler_store.hpp"
namespace free_rtos {
struct UDPHandlerArgs : public IpHandlerArgs {
void * p_data;
uint32_t len;
TUdpHeader udp_header;
};
enum UDPToggle : uint32_t {
@ -46,9 +47,8 @@ public:
bool use_chksum);
virtual int32_t Process(uint8_t * p_data, uint32_t len) override;
virtual uint32_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) override;
virtual uint16_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) override;
bool capture_buffer();
size_t get_data_size();
int32_t read(uint8_t * p_data, uint32_t len);
@ -61,8 +61,8 @@ public:
return 0;
}
if (buff_[toggle_].empty() == true) {
if(capture_buffer() == true) {
if (buff_[toggle_].size() == 0) {
if(capture_buffer() == false) {
return 0;
}
}
@ -79,9 +79,12 @@ public:
}
void clear();
void clear_async() {
buff_[out_toggle_].clear();
}
private:
const uint32_t max_buf_size = 0x1800; // 0x1800 - 6144, 0x4000 - 16384, 32768, 0x10000 - 65536, 0x11CA - 4554, 0x0BDC - 3036, 0x100000 - 1Mb
const uint32_t max_buf_size = 0x0C00; // 0x0C00 - 3072, 0x1800 - 6144, 0x4000 - 16384, 32768, 0x10000 - 65536, 0x11CA - 4554, 0x0BDC - 3036, 0x100000 - 1Mb
const uint16_t port_dst_be_; /// big endian
const uint16_t port_src_be_; /// big endian
@ -102,13 +105,14 @@ private:
Semaphore rx_sem_;
void put_data(uint8_t * p_data, uint32_t len);
int32_t get_data(uint8_t * p_data, uint32_t len);
size_t get_data(uint8_t * p_data, uint32_t len);
bool capture_buffer();
template<class T, class Allocator>
int32_t get_data(std::vector<T, Allocator>& data, uint32_t len)
size_t get_data(std::vector<T, Allocator>& data, uint32_t len)
{
std::vector<uint8_t>& buff = buff_[toggle_];
uint32_t size = buff.size();
std::vector<uint8_t>& buff = buff_[out_toggle_];
size_t size = buff.size();
if (size > len) {
size = len;
@ -126,6 +130,8 @@ private:
void set_src_ip(uint32_t src_ip) {
src_ip_ = src_ip;
}
inline uint16_t fill_udp_header(UDPHandlerArgs& udpHandlerArgs);
};
}

2
components/free_rtos/ethernet_ip/eth_udp_server.cpp
View File

@ -75,7 +75,7 @@ int32_t free_rtos::EthUdpServer::Process(uint8_t * p_data, uint32_t len)
return 0;
}
uint32_t free_rtos::EthUdpServer::Sender(HandlerArgs& handlerArgs, size_t scatter_segment)
uint16_t free_rtos::EthUdpServer::Sender(HandlerArgs& handlerArgs, size_t scatter_segment)
{
return 0;
}

2
components/free_rtos/ethernet_ip/eth_udp_server.hpp
View File

@ -30,7 +30,7 @@ public:
bool use_chksum) override;
virtual int32_t Process(uint8_t * p_data, uint32_t len) override;
virtual uint32_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) override;
virtual uint16_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) override;
virtual int32_t select(uint32_t ticks = SystemP_WAIT_FOREVER) override
{

2
components/free_rtos/handler_store/handler.hpp
View File

@ -18,7 +18,7 @@ struct HandlerArgs {
class Handler {
public:
virtual int32_t Process(uint8_t * p_data, uint32_t len) = 0;
virtual uint32_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) = 0;
virtual uint16_t Sender(HandlerArgs& handlerArgs, size_t scatter_segment) = 0;
~Handler() {};
};