EK-TM4C1294XL: EK-TM4C1294XL Ethernet : Maximum data in bytes that could be transmitted to the client side using the enet_tcp_echo example provided with the SDK.

Ryan Bernard

Part Number: EK-TM4C1294XL

Hi everyone, i had to send a large packet of data to the client side using the enet_tcp_echo.c example provided with the sdk. So i just want to know, what is the maximum data(in bytes) that i could send to the client side in 1sec or in ms using the example provided with the sdk ? If anyone has gone through such a process, please let me know the details.

over 3 years ago

0 Charles Tsai over 3 years ago

TI__Guru**** 158815 points

Hi Ryan,

There is a enet_tcpecho_server.c example in the TivaWare 2.2.0.295 release. Not sure where you get the enet_tcp_echo.c example. Suppose we are talking about the same example, there is no benchmark done to measure the throughput and sorry about that. Feel free to modify the example if you think you can optimize it for better performance. If you don't mind, please share with the community which may benefit from your findings.

0 Ryan Bernard over 3 years ago in reply to Charles Tsai

Prodigy 80 points

Hi Charles,

Thanks for the reply.I was referring to the same example. And if i can optimize it for better performance, surely i'll share it with the community . Also feel free to help me if you come across any answers regarding the same.

regards,

Ryan

0 Ryan Bernard over 3 years ago in reply to Ryan Bernard

Prodigy 80 points

Hi Charles,

I Also wanted to know whether there is any example code of udp for ek-tm4c1294xl's ethernet ? If there is any please let me know. I am in search of a code which will be able to sent multiple packets of data within 1 sec time period.

regards,

Ryan

0 Charles Tsai over 3 years ago in reply to Ryan Bernard

TI__Guru**** 158815 points

Hi Ryan,

I find this LwIP repo with the udp example and several others.

This post maybe also helpful.

https://e2e.ti.com/support/microcontrollers/other/f/908/t/723207

0 Ryan Bernard over 3 years ago in reply to Charles Tsai

Prodigy 80 points

Hi Charles,

Thanks for the help. I am a beginner so i am curious whether i'll be able to port the given program to my device as the part number is different for the given program ! Is it possible ?

regards,

Ryan

0 Charles Tsai over 3 years ago in reply to Ryan Bernard

TI__Guru**** 158815 points

Hi Ryan,

In the second link I provided is a forum post where a CCS udp_echo example project for TM4C1294 was uploaded.

0 Ryan Bernard over 3 years ago in reply to Charles Tsai

Prodigy 80 points

Hi Charles,

Thanks for your support. And in the program it divides the main clock by 100 i.e., 120MHZ is divided by 100 and in the systick handler the lwiptimer is given with a value of 10. If we wanted to send the data in microseconds, if we change the the clock division accordingly will it create any problems within the stack of udp or tcp ?

regards,

Ryan

0 Charles Tsai over 3 years ago in reply to Ryan Bernard

TI__Guru**** 158815 points

Hi Ryan,

You can try but I tend to think something may break if you are not careful. Once systick interrupt is generated it will further setup various timers with different timeout values for tcp, dhcp, arp and etc. I think if you post your question to the LwIP forum, their experts will be better answer your question. Please note the LwIP is open-source tcp/ip stacks. We don't own and not really the expert of it.

0 Ryan Bernard over 3 years ago in reply to Charles Tsai

Prodigy 80 points

Hi Charles,

I wanted to transmit data to the udp_client using the udp_sendto function. The UARTprintf function prints the Send OK, but the data never reaches the client, as well as the echo of the client works fine. The data from the server side is not displayed over the client side.I have not disables the udp echo process.

********************************************************************************************************************************************

//*****************************************************************************
//
// enet_lwip.c - Sample WebServer Application using lwIP.
//
// Copyright (c) 2013-2017 Texas Instruments Incorporated. All rights reserved.
// Software License Agreement
//
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
//
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
//
// This is part of revision 2.1.4.178 of the EK-TM4C1294XL Firmware Package.
//
//*****************************************************************************

#include <stdbool.h>
#include <stdint.h>
#include "inc/hw_ints.h"
#include "inc/hw_memmap.h"
#include "driverlib/flash.h"
#include "driverlib/interrupt.h"
#include "driverlib/gpio.h"
#include "driverlib/rom_map.h"
#include "driverlib/sysctl.h"
#include "driverlib/systick.h"
#include "utils/lwiplib.h"
#include "utils/ustdlib.h"
#include "utils/uartstdio.h"
#include "drivers/pinout.h"
#include "lwip/udp.h"

//*****************************************************************************
//
//! \addtogroup example_list
//! <h1>Ethernet with lwIP (enet_lwip)</h1>
//!
//! This example application demonstrates the operation of the Tiva
//! Ethernet controller using the lwIP TCP/IP Stack. DHCP is used to obtain
//! an Ethernet address. If DHCP times out without obtaining an address,
//! AutoIP will be used to obtain a link-local address. The address that is
//! selected will be shown on the UART.
//!
//! UART0, connected to the ICDI virtual COM port and running at 115,200,
//! 8-N-1, is used to display messages from this application. Use the
//! following command to re-build the any file system files that change.
//!
//! ../../../../tools/bin/makefsfile -i fs -o enet_fsdata.h -r -h -q
//!
//! For additional details on lwIP, refer to the lwIP web page at:
//! savannah.nongnu.org/.../
//
//*****************************************************************************

//*****************************************************************************
//
// Defines for setting up the system clock.
//
//*****************************************************************************
#define SYSTICKHZ 100
#define SYSTICKMS (1000 / SYSTICKHZ)

//*****************************************************************************
//
// Interrupt priority definitions. The top 3 bits of these values are
// significant with lower values indicating higher priority interrupts.
//
//*****************************************************************************
#define SYSTICK_INT_PRIORITY 0x80
#define ETHERNET_INT_PRIORITY 0xC0

//*****************************************************************************
//
// The current IP address.
//
//*****************************************************************************
uint32_t g_ui32IPAddress;

//*****************************************************************************
//
// The system clock frequency.
//
//*****************************************************************************
uint32_t g_ui32SysClock;

//*****************************************************************************
//
// Volatile global flag to manage LED blinking, since it is used in interrupt
// and main application. The LED blinks at the rate of SYSTICKHZ.
//
//*****************************************************************************
volatile bool g_bLED;

/********************************** calixto **********************************/
#define CS_UDP_CONNECTION_LIVE 1
#define CS_UDP_CONNECTION_OFFLINE 0

//#define UDP_ACK_OK 1
//#define UDP_ACK_WAIT 0

char cs_udp_connection_status = CS_UDP_CONNECTION_OFFLINE;
struct udp_pcb *cs_pcb;
struct pbuf *cs_pbuf;
uint8_t udp_ready_flag=0,command_rec_flag=0;
//uint8_t tcp_ack = UDP_ACK_WAIT;

//*****************************************************************************

//*****************************************************************************
//
// The error routine that is called if the driver library encounters an error.
//
//*****************************************************************************
#ifdef DEBUG
void
__error__(char *pcFilename, uint32_t ui32Line)
{
}
#endif

void udp_echo_init( void );

//*****************************************************************************
//
// Display an lwIP type IP Address.
//
//*****************************************************************************
void
DisplayIPAddress(uint32_t ui32Addr)
{
char pcBuf[16];

    //
    // Convert the IP Address into a string.
    //
    usprintf(pcBuf, "%d.%d.%d.%d", ui32Addr & 0xff, (ui32Addr >> 8) & 0xff,
            (ui32Addr >> 16) & 0xff, (ui32Addr >> 24) & 0xff);

    //
    // Display the string.
    //
    UARTprintf(pcBuf);
}

//*****************************************************************************
//
// Required by lwIP library to support any host-related timer functions.
//
//*****************************************************************************
void
lwIPHostTimerHandler(void)
{
uint32_t ui32NewIPAddress;

    //
    // Get the current IP address.
    //
    ui32NewIPAddress = lwIPLocalIPAddrGet();

    //
    // See if the IP address has changed.
    //
    if(ui32NewIPAddress != g_ui32IPAddress)
    {
        //
        // See if there is an IP address assigned.
        //
        if(ui32NewIPAddress == 0xffffffff)
        {
            //
            // Indicate that there is no link.
            //
            UARTprintf("Waiting for link.\n");
        }
        else if(ui32NewIPAddress == 0)
        {
            //
            // There is no IP address, so indicate that the DHCP process is
            // running.
            //
            UARTprintf("Waiting for IP address.\n");
        }
        else
        {
            //
            // Display the new IP address.
            //
            UARTprintf("IP Address: ");
            DisplayIPAddress(ui32NewIPAddress);
            UARTprintf("\nEcho Server is ready.\n");
       udp_ready_flag=1;
        }

        //
        // Save the new IP address.
        //
        g_ui32IPAddress = ui32NewIPAddress;
    }

    //
    // If there is not an IP address.
    //
    if((ui32NewIPAddress == 0) || (ui32NewIPAddress == 0xffffffff))
    {
        //
        // Do nothing and keep waiting.
        //
    }

  // Calixto
  cs_udp_connection_status = CS_UDP_CONNECTION_LIVE;
}

//*****************************************************************************
//
// The interrupt handler for the SysTick interrupt.
//
//*****************************************************************************
void
SysTickIntHandler(void)
{
    //
    // Call the lwIP timer handler.
    //
    lwIPTimer(SYSTICKMS);

    //
    // Tell the application to change the state of the LED (in other words
    // blink).
    //
    g_bLED = true;
}

char udp_tx_buffer[512];
void Data_Filling()
{
uint16_t j;

udp_tx_buffer[0]='{';
for(j=1; j < 501; j++)
{
udp_tx_buffer[j] = 'a';
}
udp_tx_buffer[502]='}';

}

//*****************************************************************************
//
// This example demonstrates the use of the Ethernet Controller.
//
//*****************************************************************************
int
main(void)
{
    uint32_t ui32User0, ui32User1;
    uint8_t pui8MACArray[8];

   #define LWIP_DHCP 0
   #define LWIP_AUTOIP 0

   //uint32_t cs_ipaddr=0, cs_subnet=0, cs_gateway=0;
    struct ip_addr cs_ipaddr, cs_subnet, cs_gateway;
    IP4_ADDR(&cs_ipaddr,3,0,168,192);
   IP4_ADDR(&cs_subnet,0,255,255,255);
   IP4_ADDR(&cs_gateway,1,0,168,192);

   struct ip_addr dest_ip;
   IP4_ADDR(&dest_ip,2,0,168,192);

   uint8_t cs_remote_conn_flag=0;

   ip_addr_t cs_remote_ip_addr_t;
   IP4_ADDR(&cs_remote_ip_addr_t,2,0,168,192);

    //
    // Make sure the main oscillator is enabled because this is required by
    // the PHY. The system must have a 25MHz crystal attached to the OSC
    // pins. The SYSCTL_MOSC_HIGHFREQ parameter is used when the crystal
    // frequency is 10MHz or higher.
    //
    SysCtlMOSCConfigSet(SYSCTL_MOSC_HIGHFREQ);

    //
    // Run from the PLL at 120 MHz.
    //
    g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
                                             SYSCTL_OSC_MAIN |
                                             SYSCTL_USE_PLL |
                                             SYSCTL_CFG_VCO_480), 120000000);

    //
    // Configure the device pins.
    //
    //*****************************************************************************
    //
    //! Configures the device pins for the standard usages on the EK-TM4C1294XL.
    //!
    //! \param bEthernet is a boolean used to determine function of Ethernet pins.
    //! If true Ethernet pins are configured as Ethernet LEDs. If false GPIO are
    //! available for application use.
    //! \param bUSB is a boolean used to determine function of USB pins. If true USB
    //! pins are configured for USB use. If false then USB pins are available for
    //! application use as GPIO.
    //
    //*****************************************************************************
    //    void
    // PinoutSet(bool bEthernet, bool bUSB)
    PinoutSet(true, false);

    //
    // Configure UART.
    //
    UARTStdioConfig(0, 115200, g_ui32SysClock);

    //
    // Clear the terminal and print banner.
    //
    //UARTprintf("\033[2J\033[H");
    UARTprintf("Calixto lwIP udp echo example\n\n");

    //
    // Configure Port N1 for as an output for the animation LED.
    //
    MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);

    //
    // Initialize LED to OFF (0)
    //
    MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, ~GPIO_PIN_1);

    //
    // Configure SysTick for a periodic interrupt.
    //
    MAP_SysTickPeriodSet(g_ui32SysClock / SYSTICKHZ);
    MAP_SysTickEnable();
    MAP_SysTickIntEnable();

    //
    // Configure the hardware MAC address for Ethernet Controller filtering of
    // incoming packets. The MAC address will be stored in the non-volatile
    // USER0 and USER1 registers.
    //
    MAP_FlashUserGet(&ui32User0, &ui32User1);
    if((ui32User0 == 0xffffffff) || (ui32User1 == 0xffffffff))
    {
        //
        // We should never get here. This is an error if the MAC address has
        // not been programmed into the device. Exit the program.
        // Let the user know there is no MAC address
        //
        UARTprintf("No MAC programmed!\n");
        while(1)
        {
        }
    }

    //
    // Tell the user what we are doing just now.
    //
    UARTprintf("Waiting for IP.\n");

    //
    // Convert the 24/24 split MAC address from NV ram into a 32/16 split MAC
    // address needed to program the hardware registers, then program the MAC
    // address into the Ethernet Controller registers.
    //
    pui8MACArray[0] = ((ui32User0 >> 0) & 0xff);
    pui8MACArray[1] = ((ui32User0 >> 8) & 0xff);
    pui8MACArray[2] = ((ui32User0 >> 16) & 0xff);
    pui8MACArray[3] = ((ui32User1 >> 0) & 0xff);
    pui8MACArray[4] = ((ui32User1 >> 8) & 0xff);
    pui8MACArray[5] = ((ui32User1 >> 16) & 0xff);

    //
    // Initialize the lwIP library, using DHCP.
    //

//lwIPInit(g_ui32SysClock, pui8MACArray, 0, 0, 0, IPADDR_USE_DHCP);
lwIPInit(g_ui32SysClock, pui8MACArray, cs_ipaddr.addr, cs_subnet.addr, cs_gateway.addr, IPADDR_USE_STATIC);

    //
    // Initialize the echo server.
    //Run the udpSendReceive Linux or Windows executable that is shipped with TI-RTOS.
    //The executable is found in:

//<tirtos_install_dir>\packages\examples\tools\udpSendReceive

//Usage: ./udpSendReceive <IP-addr> <port> <id> -l[length] -s[sleep in uS]

      //<IP-addr> is the IP address
      //<port>    is the UDP port being listened to (23)
      //<id>      is a unique id for the executable. Printed out when 1000 packets are
      //          transmitted. It allows the user to run multiple instances
      //          of udpSendReceive.

      //Optional:
      // -l[length]      size of the packet in bytes. Default is 1024 bytes.
      // -s[sleep in uS] usleep time to between sends. Default is 1000 uSecs.

//Example:
// udpSendReceive 192.168.1.5 23 1 -s100

//Messages such as the following will begin to appear on the terminal window when
//a UDP packet has been echoed back:

    //        Starting test with a 1000 uSec delay between transmits
    //        [id 1] count = 1000, time = 12
    //        [id 1] count = 2000, time = 24
    //        [id 1] count = 3000, time = 36
    //
    udp_echo_init();

    //
    // Set the interrupt priorities. We set the SysTick interrupt to a higher
    // priority than the Ethernet interrupt to ensure that the file system
    // tick is processed if SysTick occurs while the Ethernet handler is being
    // processed. This is very likely since all the TCP/IP and HTTP work is
    // done in the context of the Ethernet interrupt.
    //
    MAP_IntPrioritySet(INT_EMAC0, ETHERNET_INT_PRIORITY);
    MAP_IntPrioritySet(FAULT_SYSTICK, SYSTICK_INT_PRIORITY);

    //
    // Loop forever, processing the LED blinking. All the work is done in
    // interrupt handlers.
    //

    // Calixto
  Data_Filling();

  //udp_connect(cs_pcb, &cs_remote_ip_addr_t, 25);
//  cs_pbuf->payload=udp_tx_buffer;
//  cs_pbuf->len=600;
//  cs_pbuf->next = NULL;
  //dest_ip
  //cs_pcb

    while(1)
    {

       if((udp_ready_flag==1) && (command_rec_flag) == 1)
   {

     cs_pbuf = pbuf_alloc(PBUF_TRANSPORT, 512, PBUF_RAM);
       cs_pbuf->payload=udp_tx_buffer;
       cs_pbuf->tot_len = cs_pbuf->len = 512;

    udp_sendto(cs_pcb, cs_pbuf, &dest_ip, 25);

    if(udp_sendto(cs_pcb, cs_pbuf, &dest_ip, 25) == ERR_OK){

     UARTprintf("\n\rSend ok");
          pbuf_free(cs_pbuf); }
    }
        while(g_bLED == false)
        {
        }

        //
        // Clear the flag.
        //
        g_bLED = false;

        //
        // Toggle the LED.
        //
        MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1,
                         (MAP_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_1) ^
                          GPIO_PIN_1));
    }

}

void udp_echo_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, struct
ip_addr *addr, u16_t port)
{
    if (p != NULL) {
     /* send received packet back to sender */
        udp_sendto(pcb, p, addr, port);
     command_rec_flag=1;
        /* free the pbuf */
        pbuf_free(p);
    }
}

void udp_echo_init(void)
{
struct udp_pcb * pcb;

    /* get new pcb */
    pcb = udp_new();
   cs_pcb = udp_new();
    if (pcb == NULL)
  {
        LWIP_DEBUGF(UDP_DEBUG, ("udp_new failed!\n"));
        return;
    }

    /* bind to any IP address on port 23 */
    if (udp_bind(pcb, IP_ADDR_ANY, 23) != ERR_OK)
  {
        LWIP_DEBUGF(UDP_DEBUG, ("udp_bind failed!\n"));
        return;
    }

    /* set udp_echo_recv() as callback function
       for received packets */
    udp_recv(pcb, udp_echo_recv, NULL);
}

*************************************************************************************************************************************

regards,

Ryan

0 Charles Tsai over 3 years ago in reply to Ryan Bernard

TI__Guru**** 158815 points

HI,

You have a duplicated post at https://e2e.ti.com/support/microcontrollers/other/f/908/t/920055. We can use the other post to continue our discussion.

Arm-based microcontrollers

Arm-based microcontrollers forum

EK-TM4C1294XL: EK-TM4C1294XL Ethernet : Maximum data in bytes that could be transmitted to the client side using the enet_tcp_echo example provided with the SDK.