STM32 ETHENRET #2. UDP SERVER

This is second tutorial in the STM32 ETHERNET Series, ands today we will see how to create UDP Server using STM32.
UDP is the simplest protocol, and this is why I am starting with it.

This tutorial will simply cover the UDP SERVER mode, the next one will cover UDP Client mode, and similarly we will move to TCP, and then later with HTTP.

Some Insight into the CODE

The cube MX Setup is same as that in the previous tutorial. Now let’s see some code.

Initialize the UDP SERVER

void udpServer_init(void)
{
	// UDP Control Block structure
   struct udp_pcb *upcb;
   err_t err;

   /* 1. Create a new UDP control block  */
   upcb = udp_new();

   /* 2. Bind the upcb to the local port */
   ip_addr_t myIPADDR;
   IP_ADDR4(&myIPADDR, 192, 168, 0, 111);

   err = udp_bind(upcb, &myIPADDR, 7);  // 7 is the server UDP port


   /* 3. Set a receive callback for the upcb */
   if(err == ERR_OK)
   {
	   udp_recv(upcb, udp_receive_callback, NULL);
   }
   else
   {
	   udp_remove(upcb);
   }
}

To initialize the UDP Server, the following steps are taken

• Create a new UDP control block using udp_new.
• Bind the block to the local IP address and Port
• To do this we will first convert the IP address to the integer form
• Then we will use the local IP address to bind the control block using the function udp_bind.
• Once the bind is complete, the server will wait for the client to send the data.
• To do this, we can set a callback (udp_recv), which will be called whenever the server will receive the data from the client.
• Once the data is received, we can process the data, and send some reply to the client.

---

The Receive Callback

void udp_receive_callback(void *arg, struct udp_pcb *upcb, struct pbuf *p, const ip_addr_t *addr, u16_t port)
{
	struct pbuf *txBuf;

	/* Get the IP of the Client */
	char *remoteIP = ipaddr_ntoa(addr);

	char buf[100];


	int len = sprintf (buf,"Hello %s From UDP SERVER\n", (char*)p->payload);

	/* allocate pbuf from RAM*/
	txBuf = pbuf_alloc(PBUF_TRANSPORT,len, PBUF_RAM);

	/* copy the data into the buffer  */
	pbuf_take(txBuf, buf, len);

	/* Connect to the remote client */
	udp_connect(upcb, addr, port);

	/* Send a Reply to the Client */
	udp_send(upcb, txBuf);

	/* free the UDP connection, so we can accept new clients */
	udp_disconnect(upcb);

	/* Free the p_tx buffer */
	pbuf_free(txBuf);

	/* Free the p buffer */
	pbuf_free(p);
}

The receive callback is called, when the server receives some data from the client. The following shows a way to handle this data.

---

The main code

/* USER CODE BEGIN 0 */

struct netif gnetif;

/* USER CODE END 0 */

int main(void)
{

  MPU_Config();

  /* Enable I-Cache---------------------------------------------------------*/
  SCB_EnableICache();

  /* Enable D-Cache---------------------------------------------------------*/
  SCB_EnableDCache();

  HAL_Init();

  /* Configure the system clock */
  SystemClock_Config();

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_LWIP_Init();
  /* USER CODE BEGIN 2 */

  udpServer_init ();

  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */

	  ethernetif_input(&gnetif);
	  sys_check_timeouts();
  }
  /* USER CODE END 3 */
}

• Here everything is similar to the previous tutorial, except that we will also call the uspServer_init () function.
• ethernetif_input basically handles all the incoming requests.
• It calls the appropriate low level function, based on what protocol is being used.
• So we can just use the same code in the TCP also.

---

---

Result

You can see above, the data sent and received by the client.