developer
/
xiuos
forked from xuos/xiuos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'lwip' of https://gitlink.org.cn/JeremyMo/xiuos into lwip

This commit is contained in:
涂煜洋 2023-06-29 16:28:04 +08:00
parent 5b692bd0a5 db3784b928
commit 42e3b261ab
8 changed files with 579 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/ethernet/ethernetif.c
View File

@ -110,6 +110,7 @@ static char txBuf[] = "Ethernet Loop-Back Test";
/*******************************************************************************
* Local variable definitions ('static')
******************************************************************************/
/* Global Ethernet handle*/
static stc_eth_handle_t EthHandle;
/* Ethernet Tx DMA Descriptor */

2
Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/timer/connect_hwtimer.c
View File

@ -163,7 +163,7 @@ static int BoardHwtimerDevBend(void)
return ret;
}
/*K210 BOARD HWTIMER INIT*/
/*HC32F4A0 BOARD HWTIMER INIT*/
int HwTimerInit(void)
{
x_err_t ret = EOK;

4
Ubiquitous/XiZi_IIoT/resources/ethernet/LwIP/arch/lwipopts.h
View File

@ -146,7 +146,7 @@ The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums
- To use this feature let the following define uncommented.
- To disable it and process by CPU comment the the checksum.
*/
//#define CHECKSUM_BY_HARDWARE
#define CHECKSUM_BY_HARDWARE
#ifdef CHECKSUM_BY_HARDWARE
/* CHECKSUM_GEN_IP==0: Generate checksums by hardware for outgoing IP packets.*/
@ -176,7 +176,7 @@ The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums
#define CHECKSUM_CHECK_UDP 1
/* CHECKSUM_CHECK_TCP==1: Check checksums in software for incoming TCP packets.*/
#define CHECKSUM_CHECK_TCP 1
/* CHECKSUM_CHECK_ICMP==1: Check checksums by hardware for incoming ICMP packets.*/
/* CHECKSUM_CHECK_ICMP==1: Check checksums by software for incoming ICMP packets.*/
#define CHECKSUM_GEN_ICMP 1
#endif

2
Ubiquitous/XiZi_IIoT/resources/ethernet/cmd_lwip/Makefile
View File

@ -1,3 +1,3 @@
SRC_FILES := ping.c lwip_ping_demo.c lwip_tcp_demo.c lwip_udp_demo.c tcpecho_raw.c lwip_config_demo.c lwip_dhcp_demo.c
SRC_FILES := ping.c lwip_ping_demo.c lwip_tcp_demo.c lwip_udp_demo.c tcpecho_raw.c lwip_config_demo.c lwip_dhcp_demo.c iperf.c
include $(KERNEL_ROOT)/compiler.mk

510
Ubiquitous/XiZi_IIoT/resources/ethernet/cmd_lwip/iperf.c Normal file
View File

@ -0,0 +1,510 @@
/**
* iperf-liked network performance tool
*
*/
#include <xizi.h>
#include <shell.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/select.h>
#include <sys_arch.h>
#include "lwip/sockets.h"
#include <netdb.h>
#define IPERF_PORT 5001
#define IPERF_BUFSZ (4 * 1024)
#define IPERF_MODE_STOP 0
#define IPERF_MODE_SERVER 1
#define IPERF_MODE_CLIENT 2
typedef struct{
int mode;
char *host;
int port;
} IPERF_PARAM;
static IPERF_PARAM param = {IPERF_MODE_STOP, NULL, IPERF_PORT};
char tcp_iperf_ip[] = {192, 168, 131, 77};
char tcp_iperf_mask[] = {255, 255, 254, 0};
char tcp_iperf_gw[] = {192, 168, 131, 1};
static void iperf_udp_client(void *thread_param)
{
int sock;
uint32 *buffer;
struct sockaddr_in server;
uint32 packet_count = 0;
uint32 tick;
int send_size;
send_size = IPERF_BUFSZ > 1470 ? 1470 : IPERF_BUFSZ;
sock = socket(PF_INET, SOCK_DGRAM, 0);
if(sock < 0){
KPrintf("[%s:%d] can't create socket! exit!\n", __FILE__, __LINE__);
return;
}
server.sin_family = PF_INET;
server.sin_port = htons(param.port);
server.sin_addr.s_addr = inet_addr(param.host);
memset(&(server.sin_zero), 0, sizeof(server.sin_zero));
if (connect(sock, (struct sockaddr *)&server, sizeof(struct sockaddr))){
lw_error("Unable to connect\n");
closesocket(sock);
return;
}
buffer = malloc(IPERF_BUFSZ);
if (buffer == NULL){
printf("[%s:%d] malloc failed\n", __FILE__, __LINE__);
return;
}
memset(buffer, 0x00, IPERF_BUFSZ);
KPrintf("iperf udp mode run...\n");
while (param.mode != IPERF_MODE_STOP){
packet_count++;
tick = CurrentTicksGain();
buffer[0] = htonl(packet_count);
buffer[1] = htonl(tick / TICK_PER_SECOND);
buffer[2] = htonl((tick % TICK_PER_SECOND) * 1000);
sendto(sock, buffer, send_size, 0, (struct sockaddr *)&server, sizeof(struct sockaddr_in));
}
closesocket(sock);
free(buffer);
KPrintf("iperf udp mode exit...\n");
}
static void iperf_udp_server(void *thread_param)
{
int sock;
uint32 *buffer;
struct sockaddr_in server;
struct sockaddr_in sender;
int sender_len, r_size;
uint64 sentlen;
uint32 pcount = 0, last_pcount = 0;
uint32 lost, total;
x_ticks_t tick1, tick2;
struct timeval timeout;
buffer = malloc(IPERF_BUFSZ);
if (buffer == NULL){
return;
}
sock = socket(PF_INET, SOCK_DGRAM, 0);
if(sock < 0){
KPrintf("can't create socket! exit!");
return;
}
server.sin_family = PF_INET;
server.sin_port = htons(param.port);
server.sin_addr.s_addr = inet_addr("0.0.0.0");
timeout.tv_sec = 2;
timeout.tv_usec = 0;
if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) == -1){
KPrintf("setsockopt failed!");
closesocket(sock);
free(buffer);
return;
}
if (bind(sock, (struct sockaddr *)&server, sizeof(struct sockaddr_in)) < 0){
KPrintf("iperf server bind failed! exit!");
closesocket(sock);
free(buffer);
return;
}
while (param.mode != IPERF_MODE_STOP){
tick1 = CurrentTicksGain();
tick2 = tick1;
lost = 0;
total = 0;
sentlen = 0;
while ((tick2 - tick1) < (TICK_PER_SECOND * 5)){
r_size = recvfrom(sock, buffer, IPERF_BUFSZ, 0, (struct sockaddr *)&sender, (socklen_t*)&sender_len);
if (r_size > 12){
pcount = ntohl(buffer[0]);
if (last_pcount < pcount){
lost += pcount - last_pcount - 1;
total += pcount - last_pcount;
}
else{
last_pcount = pcount;
}
last_pcount = pcount;
sentlen += r_size;
}
tick2 = CurrentTicksGain();
}
if (sentlen > 0){
long data;
int integer, decimal;
KTaskDescriptorType tid;
tid = GetKTaskDescriptor();
data = sentlen * TICK_PER_SECOND / 125 / (tick2 - tick1);
integer = data/1000;
decimal = data%1000;
KPrintf("%s: %d.%03d0 Mbps! lost:%d total:%d\n", tid->task_base_info.name, integer, decimal, lost, total);
}
}
free(buffer);
closesocket(sock);
}
static void iperf_client(void *thread_param)
{
int i;
int sock;
int ret;
int tips = 1;
uint8_t *send_buf;
uint64 sentlen;
x_ticks_t tick1, tick2;
struct sockaddr_in addr;
send_buf = (uint8_t *) malloc(IPERF_BUFSZ);
if (!send_buf) return ;
for (i = 0; i < IPERF_BUFSZ; i ++)
send_buf[i] = i & 0xff;
while (param.mode != IPERF_MODE_STOP)
{
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0){
KPrintf("create socket failed!");
DelayKTask(TICK_PER_SECOND);
continue;
}
addr.sin_family = PF_INET;
addr.sin_port = htons(param.port);
addr.sin_addr.s_addr = inet_addr((char *)param.host);
ret = connect(sock, (const struct sockaddr *)&addr, sizeof(addr));
if (ret == -1){
if (tips){
KPrintf("Connect to iperf server faile, Waiting for the server to open!");
tips = 0;
}
closesocket(sock);
DelayKTask(TICK_PER_SECOND);
continue;
}
KPrintf("Connect to iperf server successful!\n");
{
int flag = 1;
setsockopt(sock,
IPPROTO_TCP, /* set option at TCP level */
TCP_NODELAY, /* name of option */
(void *) &flag, /* the cast is historical cruft */
sizeof(int)); /* length of option value */
}
sentlen = 0;
tick1 = CurrentTicksGain();
while (param.mode != IPERF_MODE_STOP){
tick2 = CurrentTicksGain();
if (tick2 - tick1 >= TICK_PER_SECOND * 5){
long data;
int integer, decimal;
KTaskDescriptorType tid;
tid = GetKTaskDescriptor();
data = sentlen * TICK_PER_SECOND / 125 / (tick2 - tick1);
integer = data/1000;
decimal = data%1000;
KPrintf("%s: %d.%03d0 Mbps!\n", tid->task_base_info.name, integer, decimal);
tick1 = tick2;
sentlen = 0;
}
ret = send(sock, send_buf, IPERF_BUFSZ, 0);
if (ret > 0){
sentlen += ret;
}
if (ret < 0) break;
}
closesocket(sock);
DelayKTask(TICK_PER_SECOND * 2);
KPrintf("Disconnected, iperf server shut down!");
tips = 1;
}
free(send_buf);
}
void iperf_server(void *thread_param)
{
uint8_t *recv_data;
socklen_t sin_size;
x_ticks_t tick1, tick2;
int sock = -1, connected, bytes_received;
uint64 recvlen;
struct sockaddr_in server_addr, client_addr;
fd_set readset;
struct timeval timeout;
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0){
KPrintf("[%s:%d] Socket error!\n", __FILE__, __LINE__);
goto __exit;
}
recv_data = (uint8_t *)malloc(IPERF_BUFSZ);
if (recv_data == NULL){
KPrintf("No memory!\n");
goto __exit;
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(param.port);
server_addr.sin_addr.s_addr = INADDR_ANY;
memset(&(server_addr.sin_zero), 0x0, sizeof(server_addr.sin_zero));
if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1){
KPrintf("Unable to bind!\n");
goto __exit;
}
if (listen(sock, 5) == -1){
KPrintf("Listen error!\n");
goto __exit;
}
timeout.tv_sec = 3;
timeout.tv_usec = 0;
while (param.mode != IPERF_MODE_STOP){
FD_ZERO(&readset);
FD_SET(sock, &readset);
if (select(sock + 1, &readset, NULL, NULL, &timeout) == 0)
continue;
sin_size = sizeof(struct sockaddr_in);
connected = accept(sock, (struct sockaddr *)&client_addr, &sin_size);
KPrintf("new client connected from (%s, %d)",
inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
int flag = 1;
setsockopt(connected,
IPPROTO_TCP, /* set option at TCP level */
TCP_NODELAY, /* name of option */
(void *) &flag, /* the cast is historical cruft */
sizeof(int)); /* length of option value */
printf(" \n"); //BUG
recvlen = 0;
tick1 = CurrentTicksGain();
while (param.mode != IPERF_MODE_STOP){
bytes_received = recv(connected, recv_data, IPERF_BUFSZ, 0);
if (bytes_received <= 0) break;
recvlen += bytes_received;
tick2 = CurrentTicksGain();
if (tick2 - tick1 >= TICK_PER_SECOND * 5){
long data;
int integer, decimal;
KTaskDescriptorType tid;
tid = GetKTaskDescriptor();
data = recvlen * TICK_PER_SECOND / 125 / (tick2 - tick1);
integer = data/1000;
decimal = data%1000;
KPrintf("%s: %d.%03d0 Mbps!\n", tid->task_base_info.name, integer, decimal);
tick1 = tick2;
recvlen = 0;
}
}
KPrintf("client disconnected (%s, %d)\n",
inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
if (connected >= 0) closesocket(connected);
connected = -1;
}
__exit:
if (sock >= 0) closesocket(sock);
if (recv_data) free(recv_data);
}
void iperf_usage(void)
{
KPrintf("Usage: iperf [-s|-c host] [options] [multi-threaded]\n");
KPrintf(" iperf [-h|--stop]\n");
KPrintf("\n");
KPrintf("Client/Server:\n");
KPrintf(" -p # server port to listen on/connect to\n");
KPrintf("\n");
KPrintf("Server specific:\n");
KPrintf(" -s run in server mode\n");
KPrintf("\n");
KPrintf("Client specific:\n");
KPrintf(" -c <host> run in client mode, connecting to <host>\n");
KPrintf("\n");
KPrintf("Miscellaneous:\n");
KPrintf(" -h print this message and quit\n");
KPrintf(" --stop stop iperf program\n");
KPrintf(" -u testing UDP protocol\n");
KPrintf(" -m <time> the number of multi-threaded \ns");
return;
}
int iperf(int argc, char **argv)
{
int mode = 0; /* server mode */
char *host = NULL;
int port = IPERF_PORT;
int numtid = 1;
int use_udp = 0;
int index = 1;
if (argc == 1)
{
goto __usage;
}
if (strcmp(argv[1], "-u") == 0)
{
index = 2;
use_udp = 1;
}
if (strcmp(argv[index], "-h") == 0) goto __usage;
else if (strcmp(argv[index], "--stop") == 0)
{
/* stop iperf */
param.mode = IPERF_MODE_STOP;
return 0;
}
else if (strcmp(argv[index], "-s") == 0)
{
mode = IPERF_MODE_SERVER; /* server mode */
/* iperf -s -p 5000 */
if (argc >= 4)
{
if (strcmp(argv[index + 1], "-p") == 0)
{
port = atoi(argv[index + 2]);
}
else goto __usage;
}
}
else if (strcmp(argv[index], "-c") == 0)
{
mode = IPERF_MODE_CLIENT; /* client mode */
if (argc < 3) goto __usage;
host = argv[index + 1];
if (argc >= 5)
{
/* iperf -c host -p port */
if (strcmp(argv[index + 2], "-p") == 0)
{
port = atoi(argv[index + 3]);
}
else goto __usage;
}
}
else goto __usage;
if (argc >= 7)
{
if(strcmp(argv[argc - 2], "-m") == 0)
{
numtid = atoi(argv[argc - 1]);
}
else goto __usage;
}
/* start iperf */
if (param.mode == IPERF_MODE_STOP)
{
int i = 0;
char tid_name[NAME_NUM_MAX + 1] = {0};
param.mode = mode;
param.port = port;
if (param.host)
{
free(param.host);
param.host = NULL;
}
if (host) param.host = strdup(host);
for (i = 0; i < numtid; i++)
{
int32 tid = 0;
void (*function)(void *parameter);
if (use_udp)
{
if (mode == IPERF_MODE_CLIENT)
{
snprintf(tid_name, sizeof(tid_name), "iperfc%02d", i + 1);
function = iperf_udp_client;
}
else if (mode == IPERF_MODE_SERVER)
{
snprintf(tid_name, sizeof(tid_name), "iperfd%02d", i + 1);
function = iperf_udp_server;
}
}
else
{
if (mode == IPERF_MODE_CLIENT)
{
snprintf(tid_name, sizeof(tid_name), "iperfc%02d", i + 1);
function = iperf_client;
}
else if (mode == IPERF_MODE_SERVER)
{
snprintf(tid_name, sizeof(tid_name), "iperfd%02d", i + 1);
function = iperf_server;
}
}
tid = KTaskCreate(tid_name, function, NULL, LWIP_TASK_STACK_SIZE, 20);
if (tid) StartupKTask(tid);
}
}
else
{
KPrintf("Please stop iperf firstly, by:\n");
KPrintf("iperf --stop\n");
}
return 0;
__usage:
iperf_usage();
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(8),
iperf, iperf, netutils iperf);

33
Ubiquitous/XiZi_IIoT/resources/ethernet/cmd_lwip/lwip_tcp_demo.c
View File

@ -25,9 +25,13 @@
#include "tcpecho_raw.h"
#include <shell.h>
#include <sys.h>
#include <xizi.h>
char tcp_demo_msg[LWIP_TEST_MSG_SIZE] = { 0 };
char tcp_demo_ip[] = {192, 168, 250, 252};
u16_t tcp_demo_port = LWIP_TARGET_PORT;
int tcp_send_num = 0;
int tcp_send_task_on = 0;
uint32 tcp_interval = 50;
/******************************************************************************/
@ -58,17 +62,34 @@ static void LwipTcpSendTask(void *arg)
lw_notice("tcp connect success, start to send.\n");
lw_notice("\n\nTarget Port:%d\n\n", tcp_sock.sin_port);
tcp_send_task_on = 1;
sendto(fd, tcp_demo_msg, strlen(tcp_demo_msg), 0, (struct sockaddr*)&tcp_sock, sizeof(struct sockaddr));
lw_notice("Send tcp msg: %s ", tcp_demo_msg);
while(tcp_send_num > 0 || tcp_send_num == -1)
{
sendto(fd, tcp_demo_msg, strlen(tcp_demo_msg), 0, (struct sockaddr*)&tcp_sock, sizeof(struct sockaddr));
lw_notice("Send tcp msg: %s \n", tcp_demo_msg);
if(tcp_send_num > 0)
{
tcp_send_num--;
}
DelayKTask(tcp_interval);
}
closesocket(fd);
tcp_send_task_on = 0;
return;
}
void LwipTcpSendTest(int argc, char *argv[])
{
if(tcp_send_task_on){
tcp_send_num = 0;
printf("waitting send task exit...\n");
while(tcp_send_task_on){
DelayKTask(1000);
}
tcp_send_num = 1;
}
LwipTcpSocketParamType param;
uint8_t enet_port = 0;
memset(tcp_demo_msg, 0, LWIP_TEST_MSG_SIZE);
@ -88,8 +109,10 @@ void LwipTcpSendTest(int argc, char *argv[])
{
sscanf(argv[2], "%d.%d.%d.%d", &tcp_demo_ip[0], &tcp_demo_ip[1], &tcp_demo_ip[2], &tcp_demo_ip[3]);
}
sscanf(argv[3], "%d", &tcp_send_num);
sscanf(argv[4], "%d", &tcp_interval);
}
lw_notice("get ipaddr %d.%d.%d.%d:%d\n", tcp_demo_ip[0], tcp_demo_ip[1], tcp_demo_ip[2], tcp_demo_ip[3], tcp_demo_port);
lw_notice("get ipaddr %d.%d.%d.%d:%d send msg %d times\n", tcp_demo_ip[0], tcp_demo_ip[1], tcp_demo_ip[2], tcp_demo_ip[3], tcp_demo_port, tcp_send_num);
lwip_config_tcp(enet_port, lwip_ipaddr, lwip_netmask, tcp_demo_ip);
memcpy(param.ip, tcp_demo_ip, 4);
@ -101,7 +124,7 @@ void LwipTcpSendTest(int argc, char *argv[])
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(3),
TCPSend, LwipTcpSendTest, TCP Send message);
TCPSend, LwipTcpSendTest, TCPSend msg [ip:port [num [interval]]]);
void LwipTcpRecvTest(void)
{

39
Ubiquitous/XiZi_IIoT/resources/ethernet/cmd_lwip/lwip_udp_demo.c
View File

@ -23,14 +23,18 @@
#include "lwip/sockets.h"
#include <shell.h>
#include <sys.h>
#include <xizi.h>
#define PBUF_SIZE 27
static struct udp_pcb *udpecho_raw_pcb;
char udp_demo_ip[] = {192, 168, 250, 252};
char udp_demo_ip[] = {192, 168, 131, 1};
u16_t udp_demo_port = LWIP_TARGET_PORT;
int32 udp_send_num = 0;
int8 udp_send_task_on = 0;
uint32 udp_interval = 50;
char hello_str[] = {"hello world\r\n"};
char udp_demo_msg[] = "\nThis one is UDP package!!!\n";
@ -66,21 +70,37 @@ static void LwipUDPSendTask(void *arg)
lw_notice("UDP connect success, start to send.\n");
lw_notice("\n\nTarget Port:%d\n\n", udp_sock.sin_port);
udp_send_task_on = 1;
sendto(socket_fd, udp_demo_msg, strlen(udp_demo_msg), 0, (struct sockaddr*)&udp_sock, sizeof(struct sockaddr));
lw_notice("Send UDP msg: %s ", udp_demo_msg);
while(udp_send_num > 0 || udp_send_num == -1)
{
sendto(socket_fd, udp_demo_msg, strlen(udp_demo_msg), 0, (struct sockaddr*)&udp_sock, sizeof(struct sockaddr));
lw_notice("Send UDP msg: %s \n", udp_demo_msg);
DelayKTask(udp_interval);
udp_send_num--;
}
closesocket(socket_fd);
udp_send_task_on = 0;
return;
}
void *LwipUdpSendTest(int argc, char *argv[])
{
if(udp_send_task_on){
udp_send_num = 0;
printf("waitting send task exit...\n");
while(udp_send_task_on){
DelayKTask(1000);
}
udp_send_num = 1;
}
uint8_t enet_port = 0; ///< test enet port 0
memset(udp_demo_msg, 0, sizeof(udp_demo_msg));
if(argc == 1)
{
lw_print("lw: [%s] gw %d.%d.%d.%d\n", __func__, udp_demo_ip[0], udp_demo_ip[1], udp_demo_ip[2], udp_demo_ip[3]);
lw_print("lw: [%s] gw %d.%d.%d.%d:%d\n", __func__, udp_demo_ip[0], udp_demo_ip[1], udp_demo_ip[2], udp_demo_ip[3], udp_demo_port);
strncpy(udp_demo_msg, hello_str, strlen(hello_str));
}
else
@ -89,18 +109,23 @@ void *LwipUdpSendTest(int argc, char *argv[])
strncat(udp_demo_msg, "\r\n", 2);
if(argc == 3)
{
sscanf(argv[2], "%d.%d.%d.%d", &udp_demo_ip[0], &udp_demo_ip[1], &udp_demo_ip[2], &udp_demo_ip[3]);
sscanf(argv[2], "%d.%d.%d.%d:%d", &udp_demo_ip[0], &udp_demo_ip[1], &udp_demo_ip[2], &udp_demo_ip[3], &udp_demo_port);
}
if(argc > 3)
{
sscanf(argv[3], "%d", &udp_send_num);
sscanf(argv[4], "%d", &udp_interval);
}
}
lw_print("lw: [%s] gw %d.%d.%d.%d\n", __func__, udp_demo_ip[0], udp_demo_ip[1], udp_demo_ip[2], udp_demo_ip[3]);
lw_print("lw: [%s] gw %d.%d.%d.%d:%d send time %d udp_interval %d\n", __func__, udp_demo_ip[0], udp_demo_ip[1], udp_demo_ip[2], udp_demo_ip[3], udp_demo_port, udp_send_num, udp_interval);
lwip_config_net(enet_port, lwip_ipaddr, lwip_netmask, udp_demo_ip);
sys_thread_new("udp send", LwipUDPSendTask, NULL, LWIP_TASK_STACK_SIZE, LWIP_DEMO_TASK_PRIO);
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(3),
UDPSend, LwipUdpSendTest, UDP send echo);
UDPSend, LwipUdpSendTest, UDPSend msg [ip:port [num [interval]]]);
static void LwipUdpRecvTask(void *arg, struct udp_pcb *upcb, struct pbuf *p,
const ip_addr_t *addr, u16_t port)

5
Ubiquitous/XiZi_IIoT/resources/ethernet/cmd_lwip/ping.c
View File

@ -38,6 +38,7 @@
*
*/
#include <sys/time.h>
#include <xs_ktask.h>
#include "lwip/opt.h"
@ -123,7 +124,9 @@ ping_prepare_echo( struct icmp_echo_hdr *iecho, u16_t len)
((char*)iecho)[sizeof(struct icmp_echo_hdr) + i] = (char)i;
}
#ifndef CHECKSUM_GEN_ICMP
iecho->chksum = inet_chksum(iecho, len);
#endif
}
#if PING_USE_SOCKETS
@ -274,7 +277,7 @@ ping_thread(void *arg)
lw_print("lw: [%s] ping start!\n", __func__);
ret = lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
LWIP_ASSERT("setting receive timeout failed", ret != 0);
LWIP_ASSERT("setting receive timeout failed", ret == 0);
LWIP_UNUSED_ARG(ret);
while (cnt --) {