LWIP_TCP如何理解数据发送,何时使用tcp_recved函数

int main(void){ /* USER CODE BEGIN 1 */ uint8_t key = 0; HAL_DeInit(); /* USER CODE END 1 */ /* MCU Configuration--------------------------------------------------------*/ /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ HAL_Init(); /* USER CODE BEGIN Init */ /* USER CODE END Init */ /* Configure the system clock */ SystemClock_Config(); /* USER CODE BEGIN SysInit */ /* USER CODE END SysInit */ /* Initialize all configured peripherals */ MX_GPIO_Init(); MX_DMA_Init(); MX_USART1_UART_Init(); MX_LWIP_Init(); //MX_UART5_Init(); /* USER CODE BEGIN 2 */

User_notification(&gnetif);

/* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { /* USER CODE END WHILE */

MX_LWIP_Process(); // <==> ethernetif_input(&gnetif); sys_check_timeouts(); ethernetif_set_link(netif_default); // for hot plug reconnection key = key_scan(0); if(key == KEY0_PRES){ tcp_echoserver_connect(); // create a receive/transmission connection }

if(key == KEY1_PRES){ tcp_echoserver_close(); } #ifdef USE_DHCP DHCP_Periodic_Handle(&gnetif);

#endif

// send out all received data! TransData();

/* USER CODE BEGIN 3 */ } /* USER CODE END 3 */}

struct tcp_echoserver_struct *tcp_echoserver_es = NULL;// private macro ----------------------------------------------------------------// private varaible--------------------------------------------------------------uint8_t ServerIp[4];uint8_t tcp_server_recvbuf[TCP_SERVER_RX_BUFSIZE];

// PRIVATE FUNCTIONS-------------------------------------------------------------static err_t tcp_echoserver_accept(void *arg, struct tcp_pcb *newpcb, err_t err);static err_t tcp_echoserver_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err);static void tcp_echoserver_error(void *arg, err_t err);static err_t tcp_echoserver_poll(void *arg, struct tcp_pcb *tpcb);static err_t tcp_echoserver_sent(void *arg, struct tcp_pcb *tpcb, u16_t len);static void tcp_echoserver_send(struct tcp_pcb *tpcb, struct tcp_echoserver_struct *es);static void tcp_echoserver_connection_close(struct tcp_pcb *tpcb, struct tcp_echoserver_struct *es);// --------------------------------------------------------------------/** * º¯Êý¹¦ÄÜ: TCP·þÎñÆ÷²âÊÔ * ÊäÈë²ÎÊý: ÎÞ * ·µ »Ø Öµ: ÎÞ * ˵ Ã÷: ÎÞ */void tcp_echoserver_connect(void){ main_flag &= ~((uint16_t)EMF_TCP_CONNECTED); tcp_echoserver_pcb = tcp_new();

if (tcp_echoserver_pcb != NULL) { // printf("create a new pcbn"); err_t err;

// bind local IP to designated port (TCP_SERVER_PORT) err = tcp_bind(tcp_echoserver_pcb, IP_ADDR_ANY, TCP_SERVER_PORT); if (err == ERR_OK){ //printf(" binding pcb successfullyn"); tcp_echoserver_pcb = tcp_listen(tcp_echoserver_pcb); // tcp pcb listening / monitoring tcp_accept(tcp_echoserver_pcb, tcp_echoserver_accept);// Intialize LwIP tcp_accept callback main_flag |= EMF_TCP_CONNECTED; } else { memp_free(MEMP_TCP_PCB, tcp_echoserver_pcb); // printf("Binding pcb failedn"); } } else{ // printf("create new pcb failed.n"); }}/*** brief: ¹Ø±ÕTCPÁ¬½Ó*/void tcp_echoserver_close(void){ tcp_echoserver_connection_close(tcp_echoserver_pcb, tcp_echoserver_es); //printf("¹Ø±Õtcp servern");

}/*** brief: LwIP callback of accept, recognizing link establishment!* tcp_input --> tcp_process(pcb) --> TCP_EVENT_ACCEPT,* NOTE: tcp_accept_pcb may not be the tcp_active_pcbs (here it is from tcp_active_pcbs)*/static err_t tcp_echoserver_accept(void *arg, struct tcp_pcb *newpcb, err_t err){

{ err_t ret_err; struct tcp_echoserver_struct *es; LWIP_UNUSED_ARG(arg); LWIP_UNUSED_ARG(err); // set new pcb priority tcp_setprio(newpcb, TCP_PRIO_MIN); // IMPORTANT NOTE: allocation struct mem for pcb information control es = (struct tcp_echoserver_struct *)mem_malloc(sizeof(struct tcp_echoserver_struct)); tcp_echoserver_es = es; if (es != NULL) { es->state = ES_ACCEPTED; // rcv established es->pcb = newpcb; // this is the established pcb (pcb->state == ESTABLISHED) es->retries = 0; es->p = NULL;

tcp_arg(newpcb, es); // es is now the new pcb parameters

tcp_recv(newpcb, tcp_echoserver_recv); // init tcp_recv() callback

tcp_err(newpcb, tcp_echoserver_error); // init tcp_err() callback

tcp_poll(newpcb, tcp_echoserver_poll, 1); // init tcp_poll callback ServerIp[0] = newpcb->remote_ & 0xff; //IADDR4 ServerIp[1] = (newpcb->remote_>>8) & 0xff; //IADDR3 ServerIp[2] = (newpcb->remote_>>16)& 0xff; //IADDR2 ServerIp[3] = (newpcb->remote_>>24)& 0xff; //IADDR1

//printf("Á¬½ÓµÄµçÄÔ¶ËIPΪ£º%d %d %d %dn",ServerIp[0],ServerIp[1],ServerIp[2],ServerIp[3]);

ret_err = ERR_OK; } else { // close TCP link tcp_echoserver_connection_close(newpcb, es); // return the error code ret_err = ERR_MEM; } return ret_err;

}/*** brief: TCP callback of receiving*/static err_t tcp_echoserver_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err){ char *recdata=0; struct tcp_echoserver_struct *es; err_t ret_err;

LWIP_ASSERT("arg != NULL",arg != NULL); es = (struct tcp_echoserver_struct *)arg; // if we receive an empty tcp frame from client => close connection if (p == NULL){ // remote host closed connection es->state = ES_CLOSING; if(es->p == NULL){

tcp_echoserver_connection_close(tpcb, es); // we're done sending, close connection } else {

tcp_sent(tpcb, tcp_echoserver_sent); // we're not done yet, acknowledge received packet tcp_echoserver_send(tpcb, es); // send remaining data

tcp_echoserver_send(tpcb, es); // send remaining data } ret_err = ERR_OK; } // else : a non empty frame was received from client but for some reason err != ERR_OK

else if(err != ERR_OK) { // free received pbuf if (p != NULL) { es->p = NULL; pbuf_free(p); } ret_err = err; } else if(es->state == ES_ACCEPTED) { // first data chunk in p->payload

es->state = ES_RECEIVED;

// store reference to incoming pbuf (chain)

es->p = p;

// initialize LwIP tcp_sent callback function

tcp_sent(tpcb, tcp_echoserver_sent);

recdata=(char *)malloc(p->len*sizeof(char)); if(recdata!=NULL) { memcpy(recdata, p->payload, p->len); print_msg("TCP_Server_Rec:%sn", recdata); } free(recdata); // printf send

//-- commented out bymc // tcp_echoserver_send(tpcb, es); // send back the received data (echo)

tcp_recved(tpcb, p->tot_len); // added bymc pbuf_free(p); // added bymc es->p = NULL; // added bymc

ret_err = ERR_OK; } else if (es->state == ES_RECEIVED) { // more data received from client and previous data has been already sent if(es->p == NULL) { es->p = p; recdata=(char *)malloc(p->len*sizeof(char)+1); if(recdata!=NULL) { memcpy(recdata, p->payload, p->len); recdata[p->len] = 0x0; print_msg("TCP_Server_Rec:%sn",recdata); } free(recdata);

//-- commented out bymc //tcp_echoserver_send(tpcb, es); // send back received data

tcp_recved(tpcb, p->tot_len); // added bymc pbuf_free(p); // added bymc es->p = NULL; // added bymc } else

else { struct pbuf *ptr; // chain pbufs to the end of what we recv'ed previously

ptr = es->p; pbuf_chain(ptr, p); } ret_err = ERR_OK; } else if(es->state == ES_CLOSING) { // odd case, remote side closing twice, trash data

tcp_recved(tpcb, p->tot_len); es->p = NULL; pbuf_free(p); ret_err = ERR_OK; } else { // unkown es->state, trash data tcp_recved(tpcb, p->tot_len); es->p = NULL; pbuf_free(p); ret_err = ERR_OK; } return ret_err;}/*** brief: TCP´íÎó»Øµ÷º¯Êý*/static void tcp_echoserver_error(void *arg, err_t err){ struct tcp_echoserver_struct *es; LWIP_UNUSED_ARG(err); es = (struct tcp_echoserver_struct *)arg; if (es != NULL) { /* free es structure */ mem_free(es); }}/*** brief: TCP_poll»Øµ÷º¯Êý*/static err_t tcp_echoserver_poll(void *arg, struct tcp_pcb *tpcb){ err_t ret_err; struct tcp_echoserver_struct * es; es = (struct tcp_echoserver_struct *)arg; if (es != NULL) { if (es->p != NULL) { tcp_sent(tpcb, tcp_echoserver_sent); // there is a remaining pbuf (chain) , try to send data tcp_echoserver_send(tpcb, es); } else { //* no remaining pbuf (chain)

//* no remaining pbuf (chain) if(es->state == ES_CLOSING) { // close tcp connection tcp_echoserver_connection_close(tpcb, es); } } ret_err = ERR_OK; } else { // nothing to be done tcp_abort(tpcb); ret_err = ERR_ABRT; } return ret_err;}/*** brief: TCP·¢Ëͻص÷º¯Êý*/static err_t tcp_echoserver_sent(void *arg, struct tcp_pcb *tpcb, u16_t len){ struct tcp_echoserver_struct *es; LWIP_UNUSED_ARG(len); es = (struct tcp_echoserver_struct *)arg; es->retries = 0; if(es->p != NULL) { // still got pbufs to send

tcp_sent(tpcb, tcp_echoserver_sent); tcp_echoserver_send(tpcb, es); } else { // if no more data to send and client closed connection if(es->state == ES_CLOSING) tcp_echoserver_connection_close(tpcb, es); } return ERR_OK;}/*** brief: TCP·¢ËÍÊý¾Ýº¯Êý*/static void tcp_echoserver_send(struct tcp_pcb *tpcb, struct tcp_echoserver_struct *es){ struct pbuf *ptr; err_t wr_err = ERR_OK; while ((wr_err == ERR_OK) && (es->p != NULL) &&

(es->p->len <= tcp_sndbuf(tpcb))) { // get pointer on pbuf from es structure ptr = es->p; // enqueue data for transmission wr_err = tcp_write(tpcb, ptr->payload, ptr->len, 1); if (wr_err == ERR_OK) { u16_t plen;

u16_t plen; u8_t freed; plen = ptr->len; // continue with next pbuf in chain (if any) es->p = ptr->next; if(es->p != NULL){ // increment reference count for es->p pbuf_ref(es->p); } // chop first pbuf from chain do { // try hard to free pbuf freed = pbuf_free(ptr); } while(freed == 0);

// we can read more data now //---->useless now, can be removed // tcp_recved(tpcb, plen);

} else if(wr_err == ERR_MEM) { // we are low on memory, try later / harder, defer to poll

es->p = ptr; tcp_output(tpcb);

} else { // other problem ??

} }}/*** brief: ¹Ø±ÕTCPÁ¬½Óº¯Êý*/static void tcp_echoserver_connection_close(struct tcp_pcb *tpcb, struct tcp_echoserver_struct *es){

/* remove all callbacks */ tcp_arg(tpcb, NULL); tcp_sent(tpcb, NULL); tcp_recv(tpcb, NULL); tcp_err(tpcb, NULL); tcp_poll(tpcb, NULL, 0); /* delete es structure */ if (es != NULL) { mem_free(es); }

/* close tcp connection */ tcp_close(tpcb);

main_flag &= ~((uint16_t)EMF_TCP_CONNECTED);}int16_t TcpProcessTransmission(uint8_t *pData, uint16_t Len){ err_t wr_err = ERR_OK; struct tcp_pcb * pcb = NULL; if(tcp_echoserver_es){ pcb = tcp_echoserver_es->pcb;

pcb = tcp_echoserver_es->pcb;

}

if(pcb && (main_flag & EMF_TCP_CONNECTED)){ wr_err = tcp_write(pcb, pData, Len, 1); if (wr_err == ERR_OK) {

// we can read more data now // tcp_recved(pcb, Len);

} else if(wr_err == ERR_MEM) { // we are low on memory, try later / harder, defer to poll

tcp_output(pcb);

} else { // other problem ??

} return Len; } return 0;}#endif /* LWIP_TCP */app_ethernet.h

#ifndef __APP_ETHERNET_H#define __APP_ETHERNET_H/* °üº¬Í·Îļþ ----------------------------------------------------------------*/#include "lwip/netif.h"#include "tcp_def.h"

/* ÀàÐͶ¨Òå ------------------------------------------------------------------*//* ºê¶¨Òå --------------------------------------------------------------------*/#define DHCP_OFF (uint8_t) 0#define DHCP_START (uint8_t) 1#define DHCP_WAIT_ADDRESS (uint8_t) 2#define DHCP_ADDRESS_ASSIGNED (uint8_t) 3#define DHCP_TIMEOUT (uint8_t) 4#define DHCP_LINK_DOWN (uint8_t) 5

/* À©Õ¹±äÁ¿ ------------------------------------------------------------------*//* º¯ÊýÉùÃ÷ ------------------------------------------------------------------*/#ifdef __cplusplusextern "C" {#endifvoid User_notification(struct netif *netif);#ifdef USE_DHCPvoid DHCP_Process(struct netif *netif);void DHCP_Periodic_Handle(struct netif *netif);#endif

#ifdef __cplusplus}#endif#endif /* __APP_ETHERNET_H *//******************* (C) COPYRIGHT 2015-2020 ӲʯǶÈëʽ¿ª·¢ÍÅ¶Ó *****END OF FILE****/app_ethernet.c/* °üº¬Í·Îļþ ----------------------------------------------------------------*/#include #include "stm32f4xx_hal.h"#include "lwip/dhcp.h"#include "app_ethernet.h"#ifdef USE_DHCP#define MAX_DHCP_TRIES 4extern uint32_t DHCPfineTimer; // = 0;__IO uint8_t DHCP_state = DHCP_OFF;__IO uint8_t DHCP_flag=0;#endif/*** brief: test tcp server. semd IP address info on netif-up*/void User_notification(struct netif *netif)

{

if (netif_is_up(netif)){ #ifdef USE_DHCP

DHCP_state = DHCP_START; // Update DHCP state machine print_msg("IP address: %sn", ip4addr_ntoa((const ip4_addr_t *)&netif->ip_addr));

print_msg("IP address: %sn", ip4addr_ntoa((const ip4_addr_t *)&netif->ip_addr)); #else uint8_t iptxt[20]; sprintf((char *)iptxt, "%s", ip4addr_ntoa((const ip4_addr_t *)&netif->ip_addr)); printf ("Static IP address: %sn", iptxt); #endif // USE_DHCP

} else{

#ifdef USE_DHCP DHCP_state = DHCP_LINK_DOWN; // Update DHCP state machine #endif // USE_DHCP print_msg("The network cable is not connected n"); }

}/** * º¯Êý¹¦ÄÜ: ¶ÔÁ´½Ó״̬½øÐÐ֪ͨ * ÊäÈë²ÎÊý: ÎÞ * ·µ »Ø Öµ: ÎÞ * ˵ Ã÷: ÎÞ */void ethernetif_notify_conn_changed(struct netif *netif){ #ifndef USE_DHCP ip_addr_t ipaddr; ip_addr_t netmask; ip_addr_t gw; #endif

if(netif_is_link_up(netif)) { print_msg("The network cable is now connected n");

#ifdef USE_DHCP

DHCP_state = DHCP_START; // Update DHCP state machine #else IP_ADDR4(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3); IP_ADDR4(&netmask, NETMASK_ADDR0, NETMASK_ADDR1 , NETMASK_ADDR2, NETMASK_ADDR3); IP_ADDR4(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);

netif_set_addr(netif, &ipaddr , &netmask, &gw);

uint8_t iptxt[20]; sprintf((char *)iptxt, "%s", ip4addr_ntoa((const ip4_addr_t *)&netif->ip_addr)); printf ("Static IP address: %sn", iptxt); #endif // USE_DHCP netif_set_up(netif); // When the netif is fully configured this function must be called. print_msg("IP address: %sn", ip4addr_ntoa((const ip4_addr_t *)&netif->ip_addr)); }

else { #ifdef USE_DHCP DHCP_state = DHCP_LINK_DOWN; // Update DHCP state machine #endif // USE_DHCP

netif_set_down(netif); // When the netif link is down this function must be called. print_msg ("The network cable is not connected.n"); }}#ifdef USE_DHCP/***brief: retrieve DHCP*/void DHCP_Process(struct netif *netif){

ip_addr_t ipaddr; ip_addr_t netmask; ip_addr_t gw; struct dhcp *dhcp;

switch (DHCP_state) { case DHCP_START: { ip_addr_set_zero_ip4(&netif->ip_addr); ip_addr_set_zero_ip4(&netif->netmask); ip_addr_set_zero_ip4(&netif->gw); DHCP_state = DHCP_WAIT_ADDRESS; dhcp_start(netif); print_msg("State: Looking for DHCP server ...n"); break; } case DHCP_WAIT_ADDRESS: { if (dhcp_supplied_address(netif))

{ DHCP_state = DHCP_ADDRESS_ASSIGNED; print_msg("IP address assigned by a DHCP server: %sn", ip4addr_ntoa((const ip4_addr_t *)&netif->ip_addr)); DHCP_flag=1; } else { dhcp = (struct dhcp *)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP); // DHCP timeout if (dhcp->tries > MAX_DHCP_TRIES) { DHCP_state = DHCP_TIMEOUT; // Stop DHCP dhcp_stop(netif); // Static address used IP_ADDR4(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 ); IP_ADDR4(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3); IP_ADDR4(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3); netif_set_addr(netif, &ipaddr, &netmask, &gw);

print_msg("DHCP Timeout !! n"); print_msg("Static IP address: %sn", ip4addr_ntoa((const ip4_addr_t *)&netif->ip_addr)); } } break; }

case DHCP_LINK_DOWN: { // Stop DHCP dhcp_stop(netif); DHCP_state = DHCP_OFF; break; } default: break; }}/** * º¯Êý¹¦ÄÜ: DHCPÂÖѯ * ÊäÈë²ÎÊý: ÎÞ * ·µ »Ø Öµ: ÎÞ

* ˵ Ã÷: ÎÞ */void DHCP_Periodic_Handle(struct netif *netif){

// Fine DHCP periodic process every 500ms if (HAL_GetTick() - DHCPfineTimer >= DHCP_FINE_TIMER_MSECS) { DHCPfineTimer = HAL_GetTick();

DHCP_Process(netif); // process DHCP state machine }}#endif