Do you wanna send any data to client from server, if the communication
restarts. didn't understand your question
Murat PALACI
Electronic & Software Designer
________________________________
From: lwip-users <lwip-users-bounces+askermp=hotmail....@nongnu.org> on behalf
of fatmanur disci <ndi...@gmail.com>
Sent: Monday, July 26, 2021 4:21:19 PM
To: lwip-users@nongnu.org <lwip-users@nongnu.org>
Subject: [lwip-users] about stm32f7 LwIP tcp client source code
Hello everyone,
I kindly need your help. I am working on an STM32F7 chip and using CubeMx LWIP
stack RMII interface . If the user wants , network parameters of stm can be
changed. First I tried the tcp server application and it worked. Server was stm
and the client was a pc. But what if the client forgot the stm's ip address
after several ip address changes ? Now I am trying to write a tcp client source
and header file for stm. I want to send any data or ping to 192.168.1.1 server
ip address.But I don't know how to do it. Is there any sample code ? I will
post my source and header code. How to write send_data() function so that stm
as a client starts communication via send ping or data to pc.
Thanks.
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __TCP_CLIENT_H__
#define __TCP_CLIENT_H__
/* Includes ------------------------------------------------------------------*/
#include "lwip/tcp.h"
#define SERVER_IP1 192
#define SERVER_IP2 168
#define SERVER_IP3 1
#define SERVER_IP4 1
#define SERVER_PORT 7
/* Exported types ------------------------------------------------------------*/
typedef struct
{
char rxBuffer[100];
char txBuffer[100];
uint8_t txBuffer2[100];
uint8_t rxDataLen;
uint8_t txDataLen;
uint8_t u8fRxBuffReadyFlag;
struct tcp_pcb *tpcb;
}tsTCPDataDef
void tcp_client_callback_connect(void);
#endif /* __TCP_CLIENT_H__ */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "lwip/debug.h"
#include "lwip/stats.h"
#include "lwip/tcp.h"
#include "lwip/memp.h"
#include <stdio.h>
#include <string.h>
#include "tcp_client.h"
#if LWIP_TCP
/* Private variables ---------------------------------------------------------*/
tsTCPDataDef tsTCPData;
static struct tcp_pcb *tcpPcb;
/* Private function prototypes -----------------------------------------------*/
static err_t tcp_client_callback_recv(void *arg, struct tcp_pcb *tpcb, struct
pbuf *p, err_t err);
static void tcp_client_callback_connection_close(struct tcp_pcb *tpcb);
static err_t tcp_client_callback_poll(void *arg, struct tcp_pcb *tpcb);
static err_t tcp_client_callback_sent(void *arg, struct tcp_pcb *tpcb, u16_t
len);
static err_t tcp_client_callback_connected(void *arg, struct tcp_pcb *tpcb,
err_t err);
static void send_data(void);
/**
* @brief Connects to the TCP echo server
* @param None
* @retval None
*/
void tcp_client_callback_connect(void)
{
ip_addr_t DestIPaddr;
/* create new tcp pcb */
tcpPcb = tcp_new();
if (tcpPcb != NULL)
{
IP4_ADDR( &DestIPaddr, SERVER_IP1, SERVER_IP2, SERVER_IP3, SERVER_IP4 );
/* connect to destination address/port */
tcp_connect(tcpPcb,&DestIPaddr,SERVER_PORT,tcp_client_callback_connected);
}
else
{
/* deallocate the pcb */
memp_free(MEMP_TCP_PCB, tcpPcb);
}
}
/**
* @brief Function called when TCP connection established
* @param tpcb: pointer on the connection contol block
* @param err: when connection correctly established err should be ERR_OK
* @retval err_t: returned error
*/
static err_t tcp_client_callback_connected(void *arg, struct tcp_pcb *tpcb,
err_t err)
{
err_t ret_err;
tcp_setprio(tpcb, TCP_PRIO_NORMAL);
/* initialize LwIP tcp_recv callback function */
tcp_recv(tpcb, tcp_client_callback_recv);
/* initialize LwIP tcp_sent callback function */
tcp_sent(tpcb, tcp_client_callback_sent);
/* initialize LwIP tcp_poll callback function */
tcp_poll(tpcb, tcp_client_callback_poll, 1);
// send_data(); // ?
ret_err = ERR_OK;
return ret_err;
}
/**
* @brief tcp_receiv callback
* @param arg: argument to be passed to receive callback
* @param tpcb: tcp connection control block
* @param err: receive error code
* @retval err_t: retuned error
*/
static err_t tcp_client_callback_recv(void *arg, struct tcp_pcb *tpcb, struct
pbuf *p, err_t err)
{
err_t ret_err;
/* if we receive an empty tcp frame from server => close connection */
if (p == NULL)
{
/* remote host closed connection */
/* we're done sending, close connection */
tcp_client_callback_connection_close(tpcb);
ret_err = ERR_OK;
}
/* else : a non empty frame was received from echo server but for some reason
err != ERR_OK */
else if(err != ERR_OK)
{
/* free received pbuf*/
if (p != NULL)
{
pbuf_free(p);
}
ret_err = err;
}
/* data received when connection already closed */
else
{
/* Acknowledge data reception */
tcp_recved(tpcb, p->tot_len);
pbuf_copy_partial(p, tsTCPData.rxBuffer, p->tot_len, 0);
tsTCPData.rxDataLen = p->tot_len;
tsTCPData.tpcb = tpcb;
tsTCPData.u8fRxBuffReadyFlag = 1;
/* free pbuf and do nothing */
pbuf_free(p);
ret_err = ERR_OK;
}
return ret_err;
}
///**
// * @brief function used to send data
// * @param tpcb: tcp control block
// * @param es: pointer on structure of type echoclient containing info on
data
// * to be sent
// * @retval None
// */
//static void tcp_client_send(struct tcp_pcb *tpcb, char* str)
//{
// struct pbuf *p;
//
// /* allocate pbuf from pool*/
// p = pbuf_alloc(PBUF_TRANSPORT,strlen((char*)str), PBUF_POOL);
//
// if (p != NULL)
// {
// /* copy data to pbuf */
// pbuf_take(p, (char*)str, strlen((char*)str));
//
// /* send tcp data */
// tcp_sent(tpcb, tcp_client_callback_sent);
// tcp_write(tpcb, p->payload, p->len, 1);
//
// /* free pbuf */
// pbuf_free(p);
// }
//}
static void send_data(void)
{
}
/**
* @brief This function implements the tcp_poll callback function
* @param arg: pointer on argument passed to callback
* @param tpcb: tcp connection control block
* @retval err_t: error code
*/
static err_t tcp_client_callback_poll(void *arg, struct tcp_pcb *tpcb)
{
err_t ret_err;
ret_err = ERR_OK;
return ret_err;
}
/**
* @brief This function implements the tcp_sent LwIP callback (called when ACK
* is received from remote host for sent data)
* @param arg: pointer on argument passed to callback
* @param tcp_pcb: tcp connection control block
* @param len: length of data sent
* @retval err_t: returned error code
*/
static err_t tcp_client_callback_sent(void *arg, struct tcp_pcb *tpcb, u16_t
len)
{
err_t ret_err;
ret_err = ERR_OK;
return ret_err;
}
/**
* @brief This function is used to close the tcp connection with server
* @param tpcb: tcp connection control block
* @param es: pointer on echoclient structure
* @retval None
*/
static void tcp_client_callback_connection_close(struct tcp_pcb *tpcb)
{
/* remove callbacks */
tcp_arg(tpcb, NULL);
tcp_recv(tpcb, NULL);
tcp_sent(tpcb, NULL);
tcp_poll(tpcb, NULL,0);
/* close tcp connection */
tcp_close(tpcb);
}
#endif /* LWIP_TCP */
_______________________________________________
lwip-users mailing list
lwip-users@nongnu.org
https://lists.nongnu.org/mailman/listinfo/lwip-users
